@nordsym/apiclaw 1.3.6 → 1.3.8

package/src/utils/backup.ts

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

@@ -0,0 +1,315 @@
+/**
+ * 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;
+}
+
+/**
+ * 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'],
+  };
+  
+  if (options.workspace) {
+    config.env = {
+      APICLAW_WORKSPACE: options.workspace,
+    };
+  }
+  
+  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

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