commons-proxy 2.0.0

package/src/utils/claude-config.js

@@ -0,0 +1,245 @@
+/**
+ * Claude CLI Configuration Utility
+ *
+ * Handles reading and writing to the global Claude CLI settings file.
+ * Location: ~/.claude/settings.json (Windows: %USERPROFILE%\.claude\settings.json)
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { logger } from './logger.js';
+import { DEFAULT_PRESETS } from '../constants.js';
+
+/**
+ * Get the path to the global Claude CLI settings file
+ * @returns {string} Absolute path to settings.json
+ */
+export function getClaudeConfigPath() {
+    return path.join(os.homedir(), '.claude', 'settings.json');
+}
+
+/**
+ * Read the global Claude CLI configuration
+ * @returns {Promise<Object>} The configuration object or empty object if file missing
+ */
+export async function readClaudeConfig() {
+    const configPath = getClaudeConfigPath();
+    try {
+        const content = await fs.readFile(configPath, 'utf8');
+        if (!content.trim()) return { env: {} };
+        return JSON.parse(content);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            logger.warn(`[ClaudeConfig] Config file not found at ${configPath}, returning empty default`);
+            return { env: {} };
+        }
+        if (error instanceof SyntaxError) {
+            logger.error(`[ClaudeConfig] Invalid JSON in config at ${configPath}. Returning safe default.`);
+            return { env: {} };
+        }
+        logger.error(`[ClaudeConfig] Failed to read config at ${configPath}:`, error.message);
+        throw error;
+    }
+}
+
+/**
+ * Update the global Claude CLI configuration
+ * Performs a deep merge with existing configuration to avoid losing other settings.
+ *
+ * @param {Object} updates - The partial configuration to merge in
+ * @returns {Promise<Object>} The updated full configuration
+ */
+export async function updateClaudeConfig(updates) {
+    const configPath = getClaudeConfigPath();
+    let currentConfig = {};
+
+    // 1. Read existing config
+    try {
+        currentConfig = await readClaudeConfig();
+    } catch (error) {
+        // Ignore ENOENT, otherwise rethrow
+        if (error.code !== 'ENOENT') throw error;
+    }
+
+    // 2. Deep merge updates
+    const newConfig = deepMerge(currentConfig, updates);
+
+    // 3. Ensure .claude directory exists
+    const configDir = path.dirname(configPath);
+    try {
+        await fs.mkdir(configDir, { recursive: true });
+    } catch (error) {
+        // Ignore if exists
+    }
+
+    // 4. Write back to file
+    try {
+        await fs.writeFile(configPath, JSON.stringify(newConfig, null, 2), 'utf8');
+        logger.info(`[ClaudeConfig] Updated config at ${configPath}`);
+        return newConfig;
+    } catch (error) {
+        logger.error(`[ClaudeConfig] Failed to write config:`, error.message);
+        throw error;
+    }
+}
+
+/**
+ * Replace the global Claude CLI configuration entirely
+ * Unlike updateClaudeConfig, this replaces the config instead of merging.
+ *
+ * @param {Object} config - The new configuration to write
+ * @returns {Promise<Object>} The written configuration
+ */
+export async function replaceClaudeConfig(config) {
+    const configPath = getClaudeConfigPath();
+
+    // 1. Ensure .claude directory exists
+    const configDir = path.dirname(configPath);
+    try {
+        await fs.mkdir(configDir, { recursive: true });
+    } catch (error) {
+        // Ignore if exists
+    }
+
+    // 2. Write config directly (no merge)
+    try {
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+        logger.info(`[ClaudeConfig] Replaced config at ${configPath}`);
+        return config;
+    } catch (error) {
+        logger.error(`[ClaudeConfig] Failed to write config:`, error.message);
+        throw error;
+    }
+}
+
+/**
+ * Simple deep merge for objects
+ */
+function deepMerge(target, source) {
+    const output = { ...target };
+
+    if (isObject(target) && isObject(source)) {
+        Object.keys(source).forEach(key => {
+            if (isObject(source[key])) {
+                if (!(key in target)) {
+                    Object.assign(output, { [key]: source[key] });
+                } else {
+                    output[key] = deepMerge(target[key], source[key]);
+                }
+            } else {
+                Object.assign(output, { [key]: source[key] });
+            }
+        });
+    }
+
+    return output;
+}
+
+function isObject(item) {
+    return (item && typeof item === 'object' && !Array.isArray(item));
+}
+
+// ==========================================
+// Claude CLI Presets
+// ==========================================
+
+/**
+ * Get the path to the presets file
+ * @returns {string} Absolute path to claude-presets.json
+ */
+export function getPresetsPath() {
+    return path.join(os.homedir(), '.config', 'commons-proxy', 'claude-presets.json');
+}
+
+/**
+ * Read all Claude CLI presets
+ * Creates the file with default presets if it doesn't exist.
+ * @returns {Promise<Array>} Array of preset objects
+ */
+export async function readPresets() {
+    const presetsPath = getPresetsPath();
+    try {
+        const content = await fs.readFile(presetsPath, 'utf8');
+        if (!content.trim()) return DEFAULT_PRESETS;
+        return JSON.parse(content);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            // Create with defaults
+            try {
+                await fs.mkdir(path.dirname(presetsPath), { recursive: true });
+                await fs.writeFile(presetsPath, JSON.stringify(DEFAULT_PRESETS, null, 2), 'utf8');
+                logger.info(`[ClaudePresets] Created presets file with defaults at ${presetsPath}`);
+            } catch (writeError) {
+                logger.warn(`[ClaudePresets] Could not create presets file: ${writeError.message}`);
+            }
+            return DEFAULT_PRESETS;
+        }
+        if (error instanceof SyntaxError) {
+            logger.error(`[ClaudePresets] Invalid JSON in presets at ${presetsPath}. Returning defaults.`);
+            return DEFAULT_PRESETS;
+        }
+        logger.error(`[ClaudePresets] Failed to read presets at ${presetsPath}:`, error.message);
+        throw error;
+    }
+}
+
+/**
+ * Save a preset (add or update)
+ * @param {string} name - Preset name
+ * @param {Object} config - Environment variables to save
+ * @returns {Promise<Array>} Updated array of presets
+ */
+export async function savePreset(name, config) {
+    const presetsPath = getPresetsPath();
+    let presets = await readPresets();
+
+    const existingIndex = presets.findIndex(p => p.name === name);
+    const newPreset = { name, config: { ...config } };
+
+    if (existingIndex >= 0) {
+        presets[existingIndex] = newPreset;
+        logger.info(`[ClaudePresets] Updated preset: ${name}`);
+    } else {
+        presets.push(newPreset);
+        logger.info(`[ClaudePresets] Created preset: ${name}`);
+    }
+
+    try {
+        await fs.mkdir(path.dirname(presetsPath), { recursive: true });
+        await fs.writeFile(presetsPath, JSON.stringify(presets, null, 2), 'utf8');
+    } catch (error) {
+        logger.error(`[ClaudePresets] Failed to save preset:`, error.message);
+        throw error;
+    }
+
+    return presets;
+}
+
+/**
+ * Delete a preset by name
+ * @param {string} name - Preset name to delete
+ * @returns {Promise<Array>} Updated array of presets
+ */
+export async function deletePreset(name) {
+    const presetsPath = getPresetsPath();
+    let presets = await readPresets();
+
+    const originalLength = presets.length;
+    presets = presets.filter(p => p.name !== name);
+
+    if (presets.length === originalLength) {
+        logger.warn(`[ClaudePresets] Preset not found: ${name}`);
+        return presets;
+    }
+
+    try {
+        await fs.writeFile(presetsPath, JSON.stringify(presets, null, 2), 'utf8');
+        logger.info(`[ClaudePresets] Deleted preset: ${name}`);
+    } catch (error) {
+        logger.error(`[ClaudePresets] Failed to delete preset:`, error.message);
+        throw error;
+    }
+
+    return presets;
+}

package/src/utils/helpers.js

@@ -0,0 +1,51 @@
+/**
+ * Shared Utility Functions
+ *
+ * General-purpose helper functions used across multiple modules.
+ */
+
+/**
+ * Format duration in milliseconds to human-readable string
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Human-readable duration (e.g., "1h23m45s")
+ */
+export function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = seconds % 60;
+
+    if (hours > 0) {
+        return `${hours}h${minutes}m${secs}s`;
+    } else if (minutes > 0) {
+        return `${minutes}m${secs}s`;
+    }
+    return `${secs}s`;
+}
+
+
+/**
+ * Sleep for specified milliseconds
+ * @param {number} ms - Duration to sleep in milliseconds
+ * @returns {Promise<void>} Resolves after the specified duration
+ */
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Check if an error is a network error (transient)
+ * @param {Error} error - The error to check
+ * @returns {boolean} True if it is a network error
+ */
+export function isNetworkError(error) {
+    const msg = error.message.toLowerCase();
+    return (
+        msg.includes('fetch failed') ||
+        msg.includes('network error') ||
+        msg.includes('econnreset') ||
+        msg.includes('etimedout') ||
+        msg.includes('socket hang up') ||
+        msg.includes('timeout')
+    );
+}

package/src/utils/logger.js

@@ -0,0 +1,142 @@
+/**
+ * Logger Utility
+ *
+ * Provides structured logging with colors and debug support.
+ * Simple ANSI codes used to avoid dependencies.
+ */
+
+import { EventEmitter } from 'events';
+import util from 'util';
+
+const COLORS = {
+    RESET: '\x1b[0m',
+    BRIGHT: '\x1b[1m',
+    DIM: '\x1b[2m',
+
+    RED: '\x1b[31m',
+    GREEN: '\x1b[32m',
+    YELLOW: '\x1b[33m',
+    BLUE: '\x1b[34m',
+    MAGENTA: '\x1b[35m',
+    CYAN: '\x1b[36m',
+    WHITE: '\x1b[37m',
+    GRAY: '\x1b[90m'
+};
+
+class Logger extends EventEmitter {
+    constructor() {
+        super();
+        this.isDebugEnabled = false;
+        this.history = [];
+        this.maxHistory = 1000;
+    }
+
+    /**
+     * Set debug mode
+     * @param {boolean} enabled
+     */
+    setDebug(enabled) {
+        this.isDebugEnabled = !!enabled;
+    }
+
+    /**
+     * Get current timestamp string
+     */
+    getTimestamp() {
+        return new Date().toISOString();
+    }
+
+    /**
+     * Get log history
+     */
+    getHistory() {
+        return this.history;
+    }
+
+    /**
+     * Format and print a log message
+     * @param {string} level
+     * @param {string} color
+     * @param {string} message
+     * @param  {...any} args
+     */
+    print(level, color, message, ...args) {
+        // Format: [TIMESTAMP] [LEVEL] Message
+        const timestampStr = this.getTimestamp();
+        const timestamp = `${COLORS.GRAY}[${timestampStr}]${COLORS.RESET}`;
+        const levelTag = `${color}[${level}]${COLORS.RESET}`;
+
+        // Format the message with args similar to console.log
+        const formattedMessage = util.format(message, ...args);
+
+        console.log(`${timestamp} ${levelTag} ${formattedMessage}`);
+
+        // Store structured log
+        const logEntry = {
+            timestamp: timestampStr,
+            level,
+            message: formattedMessage
+        };
+
+        this.history.push(logEntry);
+        if (this.history.length > this.maxHistory) {
+            this.history.shift();
+        }
+
+        this.emit('log', logEntry);
+    }
+
+    /**
+     * Standard info log
+     */
+    info(message, ...args) {
+        this.print('INFO', COLORS.BLUE, message, ...args);
+    }
+
+    /**
+     * Success log
+     */
+    success(message, ...args) {
+        this.print('SUCCESS', COLORS.GREEN, message, ...args);
+    }
+
+    /**
+     * Warning log
+     */
+    warn(message, ...args) {
+        this.print('WARN', COLORS.YELLOW, message, ...args);
+    }
+
+    /**
+     * Error log
+     */
+    error(message, ...args) {
+        this.print('ERROR', COLORS.RED, message, ...args);
+    }
+
+    /**
+     * Debug log - only prints if debug mode is enabled
+     */
+    debug(message, ...args) {
+        if (this.isDebugEnabled) {
+            this.print('DEBUG', COLORS.MAGENTA, message, ...args);
+        }
+    }
+
+    /**
+     * Direct log (for raw output usually) - proxied to console.log but can be enhanced
+     */
+    log(message, ...args) {
+        console.log(message, ...args);
+    }
+
+    /**
+     * Print a section header
+     */
+    header(title) {
+        console.log(`\n${COLORS.BRIGHT}${COLORS.CYAN}=== ${title} ===${COLORS.RESET}\n`);
+    }
+}
+
+// Export a singleton instance
+export const logger = new Logger();

package/src/utils/native-module-helper.js

@@ -0,0 +1,162 @@
+/**
+ * Native Module Helper
+ * Detects and auto-rebuilds native Node.js modules when they become
+ * incompatible after a Node.js version update.
+ */
+
+import { execSync } from 'child_process';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import { logger } from './logger.js';
+
+/**
+ * Check if an error is a NODE_MODULE_VERSION mismatch error
+ * @param {Error} error - The error to check
+ * @returns {boolean} True if it's a version mismatch error
+ */
+export function isModuleVersionError(error) {
+    const message = error?.message || '';
+    return message.includes('NODE_MODULE_VERSION') &&
+           message.includes('was compiled against a different Node.js version');
+}
+
+/**
+ * Extract the module path from a NODE_MODULE_VERSION error message
+ * @param {Error} error - The error containing the module path
+ * @returns {string|null} The path to the .node file, or null if not found
+ */
+export function extractModulePath(error) {
+    const message = error?.message || '';
+    // Match pattern like: "The module '/path/to/module.node'"
+    const match = message.match(/The module '([^']+\.node)'/);
+    return match ? match[1] : null;
+}
+
+/**
+ * Find the package root directory from a .node file path
+ * @param {string} nodeFilePath - Path to the .node file
+ * @returns {string|null} Path to the package root, or null if not found
+ */
+export function findPackageRoot(nodeFilePath) {
+    // Walk up from the .node file to find package.json
+    let dir = dirname(nodeFilePath);
+    while (dir) {
+        const packageJsonPath = join(dir, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            return dir;
+        }
+        const parentDir = dirname(dir);
+        // Stop when we've reached the filesystem root (dirname returns same path)
+        if (parentDir === dir) {
+            break;
+        }
+        dir = parentDir;
+    }
+    return null;
+}
+
+/**
+ * Attempt to rebuild a native module
+ * @param {string} packagePath - Path to the package root directory
+ * @returns {boolean} True if rebuild succeeded, false otherwise
+ */
+export function rebuildModule(packagePath) {
+    try {
+        logger.info(`[NativeModule] Rebuilding native module at: ${packagePath}`);
+
+        // Run npm rebuild in the package directory
+        const output = execSync('npm rebuild', {
+            cwd: packagePath,
+            stdio: 'pipe', // Capture output instead of printing
+            timeout: 120000 // 2 minute timeout
+        });
+
+        // Log rebuild output for debugging
+        const outputStr = output?.toString().trim();
+        if (outputStr) {
+            logger.debug(`[NativeModule] Rebuild output:\n${outputStr}`);
+        }
+
+        logger.success('[NativeModule] Rebuild completed successfully');
+        return true;
+    } catch (error) {
+        // Include stdout/stderr from the failed command for troubleshooting
+        const stdout = error.stdout?.toString().trim();
+        const stderr = error.stderr?.toString().trim();
+        let errorDetails = `[NativeModule] Rebuild failed: ${error.message}`;
+        if (stdout) {
+            errorDetails += `\n[NativeModule] stdout: ${stdout}`;
+        }
+        if (stderr) {
+            errorDetails += `\n[NativeModule] stderr: ${stderr}`;
+        }
+        logger.error(errorDetails);
+        return false;
+    }
+}
+
+/**
+ * Attempt to auto-rebuild a native module from an error
+ * @param {Error} error - The NODE_MODULE_VERSION error
+ * @returns {boolean} True if rebuild succeeded, false otherwise
+ */
+export function attemptAutoRebuild(error) {
+    const nodePath = extractModulePath(error);
+    if (!nodePath) {
+        logger.error('[NativeModule] Could not extract module path from error');
+        return false;
+    }
+
+    const packagePath = findPackageRoot(nodePath);
+    if (!packagePath) {
+        logger.error('[NativeModule] Could not find package root');
+        return false;
+    }
+
+    logger.warn('[NativeModule] Native module version mismatch detected');
+    logger.info('[NativeModule] Attempting automatic rebuild...');
+
+    return rebuildModule(packagePath);
+}
+
+/**
+ * Recursively clear a module and its dependencies from the require cache
+ * This is needed after rebuilding a native module to force re-import
+ * @param {string} modulePath - Resolved path to the module
+ * @param {object} cache - The require.cache object
+ * @param {Set} [visited] - Set of already-visited paths to prevent cycles
+ */
+export function clearRequireCache(modulePath, cache, visited = new Set()) {
+    if (visited.has(modulePath)) return;
+    visited.add(modulePath);
+
+    const mod = cache[modulePath];
+    if (!mod) return;
+
+    // Recursively clear children first
+    if (mod.children) {
+        for (const child of mod.children) {
+            clearRequireCache(child.id, cache, visited);
+        }
+    }
+
+    // Remove from parent's children array
+    if (mod.parent && mod.parent.children) {
+        const idx = mod.parent.children.indexOf(mod);
+        if (idx !== -1) {
+            mod.parent.children.splice(idx, 1);
+        }
+    }
+
+    // Delete from cache
+    delete cache[modulePath];
+}
+
+export default {
+    isModuleVersionError,
+    extractModulePath,
+    findPackageRoot,
+    rebuildModule,
+    attemptAutoRebuild,
+    clearRequireCache
+};