@nordsym/apiclaw 1.3.6 → 1.3.8

package/landing/src/components/Toast.tsx

@@ -0,0 +1,84 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { Check, X, AlertCircle, Info } from "lucide-react";
+
+export type ToastType = "success" | "error" | "info";
+
+interface ToastProps {
+  message: string;
+  type?: ToastType;
+  duration?: number;
+  onClose: () => void;
+}
+
+export function Toast({ message, type = "success", duration = 5000, onClose }: ToastProps) {
+  const [isVisible, setIsVisible] = useState(true);
+  const [isLeaving, setIsLeaving] = useState(false);
+
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setIsLeaving(true);
+      setTimeout(onClose, 300);
+    }, duration);
+
+    return () => clearTimeout(timer);
+  }, [duration, onClose]);
+
+  const handleClose = () => {
+    setIsLeaving(true);
+    setTimeout(onClose, 300);
+  };
+
+  const icons = {
+    success: <Check className="w-5 h-5" />,
+    error: <AlertCircle className="w-5 h-5" />,
+    info: <Info className="w-5 h-5" />,
+  };
+
+  const colors = {
+    success: "bg-green-500/20 border-green-500/50 text-green-500",
+    error: "bg-red-500/20 border-red-500/50 text-red-500",
+    info: "bg-blue-500/20 border-blue-500/50 text-blue-500",
+  };
+
+  const iconBg = {
+    success: "bg-green-500/20",
+    error: "bg-red-500/20",
+    info: "bg-blue-500/20",
+  };
+
+  return (
+    <div
+      className={`fixed top-4 right-4 z-[100] flex items-center gap-3 px-4 py-3 rounded-xl border backdrop-blur-sm shadow-lg transition-all duration-300 ${
+        colors[type]
+      } ${isLeaving ? "opacity-0 translate-x-4" : "opacity-100 translate-x-0"}`}
+    >
+      <div className={`w-8 h-8 rounded-lg ${iconBg[type]} flex items-center justify-center flex-shrink-0`}>
+        {icons[type]}
+      </div>
+      <span className="text-[var(--text-primary)] font-medium">{message}</span>
+      <button
+        onClick={handleClose}
+        className="ml-2 p-1 rounded-lg hover:bg-white/10 transition"
+      >
+        <X className="w-4 h-4 text-[var(--text-muted)]" />
+      </button>
+    </div>
+  );
+}
+
+// Hook for managing toasts
+export function useToast() {
+  const [toast, setToast] = useState<{ message: string; type: ToastType } | null>(null);
+
+  const showToast = (message: string, type: ToastType = "success") => {
+    setToast({ message, type });
+  };
+
+  const hideToast = () => {
+    setToast(null);
+  };
+
+  return { toast, showToast, hideToast };
+}

package/landing/src/lib/stats.json

@@ -1,8 +1,10 @@
 {
   "apiCount": 22392,
+  "openApiCount": 1636,
+  "directCallCount": 10,
   "categoryCount": 13,
   "lastUpdated": "2026-02-27T09:10:41.344767",
-  "generatedAt": "2026-02-28T11:01:39.528Z",
+  "generatedAt": "2026-03-01T02:24:02.189Z",
   "categoryBreakdown": {
     "Finance": 1179,
     "Auth & Security": 491,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nordsym/apiclaw",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "description": "Agent-native API discovery and Direct Call execution via MCP",
   "type": "module",
   "main": "dist/index.js",
@@ -28,17 +28,24 @@
     "@hono/node-server": "^1.19.9",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@supabase/supabase-js": "^2.39.0",
+    "@types/inquirer": "^9.0.9",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
     "convex": "^1.32.0",
     "dotenv": "^17.3.1",
+    "fs-extra": "^11.3.3",
     "hono": "^4.0.0",
+    "inquirer": "^13.3.0",
+    "ora": "^9.3.0",
     "stripe": "^20.3.1"
   },
   "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.10.0",
     "tsx": "^4.7.0",
     "typescript": "^5.3.0"
   },
   "bin": {
-    "apiclaw": "./dist/index.js"
+    "apiclaw": "./dist/bin.js"
   }
 }

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
+    ];
+  }
+}