@nordsym/apiclaw 2.2.0 → 2.2.1

package/src/utils/backup.ts

@@ -1,224 +0,0 @@
-/**
- * Backup System
- * Handles timestamped backups of config files with automatic cleanup
- */
-
-import { existsSync, mkdirSync, readdirSync, unlinkSync, copyFileSync, statSync } from 'fs';
-import { dirname, basename, join, extname } from 'path';
-
-const MAX_BACKUPS = 5;
-const BACKUP_PATTERN = /\.backup\.(\d+)\.json$/;
-
-export interface BackupResult {
-  success: boolean;
-  backupPath: string | null;
-  error?: string;
-}
-
-export interface BackupInfo {
-  path: string;
-  timestamp: number;
-  date: Date;
-  filename: string;
-}
-
-/**
- * Generate backup filename with timestamp
- */
-function generateBackupFilename(originalPath: string): string {
-  const dir = dirname(originalPath);
-  const base = basename(originalPath, '.json');
-  const timestamp = Date.now();
-  
-  return join(dir, `${base}.backup.${timestamp}.json`);
-}
-
-/**
- * Create a backup of a config file
- */
-export function createBackup(configPath: string): BackupResult {
-  try {
-    // Check if original file exists
-    if (!existsSync(configPath)) {
-      return {
-        success: true,
-        backupPath: null,
-        // No backup needed if file doesn't exist
-      };
-    }
-    
-    // Ensure backup directory exists
-    const dir = dirname(configPath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    
-    // Generate backup path
-    const backupPath = generateBackupFilename(configPath);
-    
-    // Copy file
-    copyFileSync(configPath, backupPath);
-    
-    // Cleanup old backups
-    cleanupOldBackups(configPath);
-    
-    return {
-      success: true,
-      backupPath,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      backupPath: null,
-      error: error instanceof Error ? error.message : 'Unknown error creating backup',
-    };
-  }
-}
-
-/**
- * List all backups for a config file
- */
-export function listBackups(configPath: string): BackupInfo[] {
-  const dir = dirname(configPath);
-  const baseName = basename(configPath, '.json');
-  
-  if (!existsSync(dir)) {
-    return [];
-  }
-  
-  const files = readdirSync(dir);
-  const backups: BackupInfo[] = [];
-  
-  for (const file of files) {
-    // Match backup pattern: {basename}.backup.{timestamp}.json
-    const match = file.match(new RegExp(`^${escapeRegex(baseName)}\\.backup\\.(\\d+)\\.json$`));
-    
-    if (match) {
-      const timestamp = parseInt(match[1], 10);
-      const fullPath = join(dir, file);
-      
-      backups.push({
-        path: fullPath,
-        timestamp,
-        date: new Date(timestamp),
-        filename: file,
-      });
-    }
-  }
-  
-  // Sort by timestamp, newest first
-  return backups.sort((a, b) => b.timestamp - a.timestamp);
-}
-
-/**
- * Get the most recent backup
- */
-export function getLatestBackup(configPath: string): BackupInfo | null {
-  const backups = listBackups(configPath);
-  return backups[0] || null;
-}
-
-/**
- * Cleanup old backups, keeping only MAX_BACKUPS most recent
- */
-export function cleanupOldBackups(configPath: string): number {
-  const backups = listBackups(configPath);
-  let deleted = 0;
-  
-  // Keep only the first MAX_BACKUPS
-  const toDelete = backups.slice(MAX_BACKUPS);
-  
-  for (const backup of toDelete) {
-    try {
-      unlinkSync(backup.path);
-      deleted++;
-    } catch {
-      // Ignore deletion errors
-    }
-  }
-  
-  return deleted;
-}
-
-/**
- * Restore from a backup
- */
-export function restoreBackup(backupPath: string, targetPath: string): BackupResult {
-  try {
-    if (!existsSync(backupPath)) {
-      return {
-        success: false,
-        backupPath: null,
-        error: `Backup file not found: ${backupPath}`,
-      };
-    }
-    
-    // Backup current file before restoring
-    const preRestoreBackup = createBackup(targetPath);
-    
-    // Copy backup to target
-    copyFileSync(backupPath, targetPath);
-    
-    return {
-      success: true,
-      backupPath: preRestoreBackup.backupPath,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      backupPath: null,
-      error: error instanceof Error ? error.message : 'Unknown error restoring backup',
-    };
-  }
-}
-
-/**
- * Restore from the most recent backup
- */
-export function restoreLatestBackup(configPath: string): BackupResult {
-  const latest = getLatestBackup(configPath);
-  
-  if (!latest) {
-    return {
-      success: false,
-      backupPath: null,
-      error: 'No backups found',
-    };
-  }
-  
-  return restoreBackup(latest.path, configPath);
-}
-
-/**
- * Format backup info for display
- */
-export function formatBackupInfo(backup: BackupInfo): string {
-  const date = backup.date.toLocaleString();
-  return `${backup.filename} (${date})`;
-}
-
-/**
- * Escape regex special characters
- */
-function escapeRegex(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Delete all backups for a config file
- */
-export function deleteAllBackups(configPath: string): number {
-  const backups = listBackups(configPath);
-  let deleted = 0;
-  
-  for (const backup of backups) {
-    try {
-      unlinkSync(backup.path);
-      deleted++;
-    } catch {
-      // Ignore deletion errors
-    }
-  }
-  
-  return deleted;
-}

package/src/utils/config.ts

@@ -1,318 +0,0 @@
-/**
- * Config Management
- * Handles JSON read/write/merge operations for MCP config files
- */
-
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
-import { createBackup } from './backup.js';
-
-export interface MCPServerConfig {
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
-}
-
-export interface MCPConfig {
-  mcpServers?: Record<string, MCPServerConfig>;
-  [key: string]: unknown;
-}
-
-// Continue uses array format for mcpServers
-export interface ContinueServerConfig {
-  name: string;
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
-}
-
-export interface ContinueConfig {
-  mcpServers?: ContinueServerConfig[];
-  [key: string]: unknown;
-}
-
-export interface ConfigReadResult {
-  success: boolean;
-  config: MCPConfig | ContinueConfig | null;
-  error?: string;
-  isNew?: boolean;
-}
-
-export interface ConfigWriteResult {
-  success: boolean;
-  error?: string;
-  backupPath?: string | null;
-}
-
-export interface MergeOptions {
-  force?: boolean;
-  workspace?: string;
-  serverName?: string;
-  clientName?: string; // MCP client identifier (e.g., "cursor", "claude-desktop")
-}
-
-/**
- * Read and parse a JSON config file
- */
-export function readConfig(configPath: string): ConfigReadResult {
-  try {
-    if (!existsSync(configPath)) {
-      return {
-        success: true,
-        config: {},
-        isNew: true,
-      };
-    }
-    
-    const content = readFileSync(configPath, 'utf-8');
-    
-    // Handle empty files
-    if (!content.trim()) {
-      return {
-        success: true,
-        config: {},
-        isNew: true,
-      };
-    }
-    
-    const config = JSON.parse(content);
-    
-    return {
-      success: true,
-      config,
-      isNew: false,
-    };
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      return {
-        success: false,
-        config: null,
-        error: `Invalid JSON in config file: ${error.message}`,
-      };
-    }
-    
-    return {
-      success: false,
-      config: null,
-      error: error instanceof Error ? error.message : 'Unknown error reading config',
-    };
-  }
-}
-
-/**
- * Write config to file with backup
- */
-export function writeConfig(
-  configPath: string, 
-  config: MCPConfig | ContinueConfig,
-  createBackupFirst = true
-): ConfigWriteResult {
-  try {
-    // Ensure directory exists
-    const dir = dirname(configPath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    
-    // Create backup if file exists and backup requested
-    let backupPath: string | null = null;
-    if (createBackupFirst && existsSync(configPath)) {
-      const backupResult = createBackup(configPath);
-      if (!backupResult.success) {
-        return {
-          success: false,
-          error: `Failed to create backup: ${backupResult.error}`,
-        };
-      }
-      backupPath = backupResult.backupPath;
-    }
-    
-    // Validate JSON before writing
-    const content = JSON.stringify(config, null, 2);
-    JSON.parse(content); // Validation parse
-    
-    // Write file
-    writeFileSync(configPath, content, 'utf-8');
-    
-    return {
-      success: true,
-      backupPath,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error writing config',
-    };
-  }
-}
-
-/**
- * Deep merge two objects
- */
-export function deepMerge<T extends Record<string, unknown>>(
-  target: T,
-  source: Partial<T>
-): T {
-  const result = { ...target };
-  
-  for (const key in source) {
-    const sourceValue = source[key];
-    const targetValue = result[key];
-    
-    if (
-      sourceValue !== null &&
-      typeof sourceValue === 'object' &&
-      !Array.isArray(sourceValue) &&
-      targetValue !== null &&
-      typeof targetValue === 'object' &&
-      !Array.isArray(targetValue)
-    ) {
-      // Recursively merge objects
-      result[key] = deepMerge(
-        targetValue as Record<string, unknown>,
-        sourceValue as Record<string, unknown>
-      ) as T[Extract<keyof T, string>];
-    } else {
-      // Overwrite value
-      result[key] = sourceValue as T[Extract<keyof T, string>];
-    }
-  }
-  
-  return result;
-}
-
-/**
- * Generate APIClaw MCP server configuration
- */
-export function generateApiclawConfig(options: MergeOptions = {}): MCPServerConfig {
-  const config: MCPServerConfig = {
-    command: 'npx',
-    args: ['-y', '@nordsym/apiclaw'],
-  };
-
-  const env: Record<string, string> = {};
-  if (options.workspace) env.APICLAW_WORKSPACE = options.workspace;
-  if (options.clientName) env.APICLAW_MCP_CLIENT = options.clientName;
-
-  if (Object.keys(env).length > 0) {
-    config.env = env;
-  }
-
-  return config;
-}
-
-/**
- * Generate APIClaw config for Continue (array format)
- */
-export function generateApiclawContinueConfig(options: MergeOptions = {}): ContinueServerConfig {
-  const config: ContinueServerConfig = {
-    name: options.serverName || 'apiclaw',
-    command: 'npx',
-    args: ['-y', '@nordsym/apiclaw'],
-  };
-  
-  if (options.workspace) {
-    config.env = {
-      APICLAW_WORKSPACE: options.workspace,
-    };
-  }
-  
-  return config;
-}
-
-/**
- * Check if APIClaw is already configured
- */
-export function hasApiclawConfig(config: MCPConfig | ContinueConfig, serverName = 'apiclaw'): boolean {
-  // Handle Continue's array format
-  if (Array.isArray((config as ContinueConfig).mcpServers)) {
-    const continueConfig = config as ContinueConfig;
-    return continueConfig.mcpServers?.some(s => s.name === serverName) || false;
-  }
-  
-  // Handle standard object format
-  const mcpConfig = config as MCPConfig;
-  return mcpConfig.mcpServers?.[serverName] !== undefined;
-}
-
-/**
- * Merge APIClaw config into existing config (standard format)
- */
-export function mergeApiclawConfig(
-  existingConfig: MCPConfig,
-  options: MergeOptions = {}
-): MCPConfig {
-  const serverName = options.serverName || 'apiclaw';
-  const apiclawConfig = generateApiclawConfig(options);
-  
-  return deepMerge(existingConfig, {
-    mcpServers: {
-      ...existingConfig.mcpServers,
-      [serverName]: apiclawConfig,
-    },
-  });
-}
-
-/**
- * Merge APIClaw config into Continue config (array format)
- */
-export function mergeApiclawContinueConfig(
-  existingConfig: ContinueConfig,
-  options: MergeOptions = {}
-): ContinueConfig {
-  const serverName = options.serverName || 'apiclaw';
-  const apiclawConfig = generateApiclawContinueConfig(options);
-  
-  const existingServers = existingConfig.mcpServers || [];
-  
-  // Check if already exists
-  const existingIndex = existingServers.findIndex(s => s.name === serverName);
-  
-  let newServers: ContinueServerConfig[];
-  if (existingIndex >= 0) {
-    // Update existing
-    newServers = [...existingServers];
-    newServers[existingIndex] = apiclawConfig;
-  } else {
-    // Add new
-    newServers = [...existingServers, apiclawConfig];
-  }
-  
-  return {
-    ...existingConfig,
-    mcpServers: newServers,
-  };
-}
-
-/**
- * Remove APIClaw from config
- */
-export function removeApiclawConfig(
-  config: MCPConfig | ContinueConfig,
-  serverName = 'apiclaw'
-): MCPConfig | ContinueConfig {
-  // Handle Continue's array format
-  if (Array.isArray((config as ContinueConfig).mcpServers)) {
-    const continueConfig = config as ContinueConfig;
-    return {
-      ...continueConfig,
-      mcpServers: continueConfig.mcpServers?.filter(s => s.name !== serverName),
-    };
-  }
-  
-  // Handle standard object format
-  const mcpConfig = config as MCPConfig;
-  const { [serverName]: _, ...remainingServers } = mcpConfig.mcpServers || {};
-  
-  return {
-    ...mcpConfig,
-    mcpServers: remainingServers,
-  };
-}
-
-/**
- * Detect if config uses Continue's array format
- */
-export function isContinueFormat(config: MCPConfig | ContinueConfig): config is ContinueConfig {
-  return Array.isArray((config as ContinueConfig).mcpServers);
-}

package/src/utils/os.ts

@@ -1,124 +0,0 @@
-/**
- * OS Detection Utility
- * Detects the operating system and provides platform-specific helpers
- */
-
-import { platform, homedir } from 'os';
-import { join } from 'path';
-
-export type Platform = 'mac' | 'win' | 'linux';
-
-/**
- * Detect the current operating system
- */
-export function detectOS(): Platform {
-  const os = platform();
-  
-  switch (os) {
-    case 'darwin':
-      return 'mac';
-    case 'win32':
-      return 'win';
-    case 'linux':
-      return 'linux';
-    default:
-      // Default to linux for other Unix-like systems
-      return 'linux';
-  }
-}
-
-/**
- * Get the home directory for the current user
- */
-export function getHomeDir(): string {
-  return homedir();
-}
-
-/**
- * Get the app data directory based on OS
- * - macOS: ~/Library/Application Support
- * - Windows: %APPDATA%
- * - Linux: ~/.config
- */
-export function getAppDataDir(): string {
-  const home = getHomeDir();
-  const os = detectOS();
-  
-  switch (os) {
-    case 'mac':
-      return join(home, 'Library', 'Application Support');
-    case 'win':
-      return process.env.APPDATA || join(home, 'AppData', 'Roaming');
-    case 'linux':
-      return process.env.XDG_CONFIG_HOME || join(home, '.config');
-  }
-}
-
-/**
- * Get the user profile directory (Windows-specific, falls back to home)
- */
-export function getUserProfileDir(): string {
-  return process.env.USERPROFILE || getHomeDir();
-}
-
-/**
- * Check if running as root/admin
- */
-export function isElevated(): boolean {
-  const os = detectOS();
-  
-  if (os === 'win') {
-    // Windows admin check is more complex, skip for now
-    return false;
-  }
-  
-  // Unix-like: check if UID is 0
-  return process.getuid?.() === 0;
-}
-
-/**
- * Get OS-specific path separator
- */
-export function getPathSeparator(): string {
-  return detectOS() === 'win' ? '\\' : '/';
-}
-
-/**
- * Normalize path for current OS
- */
-export function normalizePath(path: string): string {
-  const os = detectOS();
-  
-  if (os === 'win') {
-    // Convert forward slashes to backslashes on Windows
-    return path.replace(/\//g, '\\');
-  }
-  
-  return path;
-}
-
-/**
- * Expand ~ to home directory
- */
-export function expandHome(path: string): string {
-  if (path.startsWith('~')) {
-    return join(getHomeDir(), path.slice(1));
-  }
-  return path;
-}
-
-/**
- * Get OS display name
- */
-export function getOSDisplayName(): string {
-  const os = detectOS();
-  
-  switch (os) {
-    case 'mac':
-      return 'macOS';
-    case 'win':
-      return 'Windows';
-    case 'linux':
-      return 'Linux';
-  }
-}