@nordsym/apiclaw 2.2.0 → 2.2.1

package/src/access-control.ts

@@ -1,174 +0,0 @@
-/**
- * Access Control System
- * Controls which products/agents can access which providers
- * 
- * Rules format:
- * - Wildcard: "hivr:*" = all Hivr agents
- * - Specific: "hivr:bytebee" = only ByteBee
- * - Product-level: "nordsym:*" = all NordSym agents
- * 
- * Provider wildcards:
- * - "*" = all providers
- * - "brave_*" = all Brave providers
- * - Specific: ["brave_search", "groq"]
- */
-
-interface AccessRule {
-  agentPattern: string;
-  allowedProviders: string[];
-  description?: string;
-}
-
-// Default access rules
-// These can be moved to Convex table for dynamic updates
-const DEFAULT_RULES: AccessRule[] = [
-  {
-    agentPattern: 'hivr:*',
-    allowedProviders: ['*'], // Hivr gets everything
-    description: 'All Hivr bees get full access',
-  },
-  {
-    agentPattern: 'nordsym:*',
-    allowedProviders: ['brave_search', 'groq', 'replicate'],
-    description: 'NordSym team gets selected providers',
-  },
-  // Add more rules as needed
-];
-
-// Cache for compiled rules
-let compiledRules: {
-  pattern: RegExp;
-  providers: string[];
-}[] | null = null;
-
-/**
- * Compile agentPattern to RegExp
- */
-function compilePattern(pattern: string): RegExp {
-  // Convert wildcard pattern to regex
-  // "hivr:*" → /^hivr:.+$/
-  // "hivr:byte*" → /^hivr:byte.+$/
-  const escaped = pattern
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex chars
-    .replace(/\*/g, '.+'); // Replace * with .+
-  
-  return new RegExp(`^${escaped}$`, 'i');
-}
-
-/**
- * Compile all rules (cache for performance)
- */
-function compileRules(): void {
-  compiledRules = DEFAULT_RULES.map(rule => ({
-    pattern: compilePattern(rule.agentPattern),
-    providers: rule.allowedProviders,
-  }));
-}
-
-/**
- * Check if provider matches pattern
- */
-function matchesProvider(provider: string, pattern: string): boolean {
-  if (pattern === '*') return true;
-  if (pattern.endsWith('*')) {
-    const prefix = pattern.slice(0, -1);
-    return provider.startsWith(prefix);
-  }
-  return provider === pattern;
-}
-
-/**
- * Check if agentId is allowed to access provider
- */
-export function canAccessProvider(agentId: string, provider: string): boolean {
-  if (!compiledRules) {
-    compileRules();
-  }
-  
-  const normalized = agentId.toLowerCase().trim();
-  const normalizedProvider = provider.toLowerCase().trim();
-  
-  // Find matching rule
-  for (const rule of compiledRules!) {
-    if (rule.pattern.test(normalized)) {
-      // Check if provider is allowed
-      for (const providerPattern of rule.providers) {
-        if (matchesProvider(normalizedProvider, providerPattern)) {
-          return true;
-        }
-      }
-      // Rule matched but provider not in allowlist
-      return false;
-    }
-  }
-  
-  // No rule matched = deny by default
-  console.warn(`[Access Control] No rule for ${normalized}`);
-  return false;
-}
-
-/**
- * Get allowed providers for agentId
- */
-export function getAllowedProviders(agentId: string): string[] {
-  if (!compiledRules) {
-    compileRules();
-  }
-  
-  const normalized = agentId.toLowerCase().trim();
-  
-  // Find matching rule
-  for (const rule of compiledRules!) {
-    if (rule.pattern.test(normalized)) {
-      return rule.providers;
-    }
-  }
-  
-  return [];
-}
-
-/**
- * Add new access rule (runtime)
- */
-export function addAccessRule(rule: AccessRule): void {
-  DEFAULT_RULES.push(rule);
-  compiledRules = null; // Force recompile
-  console.log(`[Access Control] Added rule for ${rule.agentPattern}`);
-}
-
-/**
- * Get all access rules (for debugging/admin)
- */
-export function getAccessRules(): AccessRule[] {
-  return [...DEFAULT_RULES];
-}
-
-/**
- * Check if agentId + provider combination is allowed
- * Combines whitelist check + access control
- */
-export async function isAllowed(
-  agentId: string | undefined,
-  provider: string
-): Promise<{ allowed: boolean; reason?: string }> {
-  if (!agentId) {
-    return { allowed: false, reason: 'No agentId provided' };
-  }
-  
-  // First check: Is agent whitelisted?
-  const { isAuthorized } = await import('./product-whitelist.js');
-  const whitelisted = await isAuthorized(agentId);
-  
-  if (!whitelisted) {
-    return { allowed: false, reason: 'Agent not whitelisted' };
-  }
-  
-  // Second check: Does agent have access to this provider?
-  const hasAccess = canAccessProvider(agentId, provider);
-  
-  if (!hasAccess) {
-    return { allowed: false, reason: 'Provider not in access list' };
-  }
-  
-  return { allowed: true };
-}

package/src/adapters/base.ts

@@ -1,364 +0,0 @@
-/**
- * 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,
-        clientName: this.name === 'custom' ? undefined : this.name,
-      };
-      
-      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

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,88 +0,0 @@
-/**
- * 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
-    ];
-  }
-}