claw-dashboard 1.9.0 → 2.1.0

package/src/plugin-validator.js

@@ -0,0 +1,284 @@
+/**
+ * Plugin Manifest Validator
+ * Validates plugin.json files against the JSON Schema
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load the schema
+const SCHEMA_PATH = resolve(__dirname, '../schemas/plugin-manifest.json');
+let schema = null;
+
+try {
+  if (existsSync(SCHEMA_PATH)) {
+    const schemaContent = readFileSync(SCHEMA_PATH, 'utf8');
+    schema = JSON.parse(schemaContent);
+  }
+} catch (err) {
+  console.warn(`Failed to load plugin schema: ${err.message}`);
+}
+
+/**
+ * Validation result type
+ * @typedef {Object} ValidationResult
+ * @property {boolean} valid - Whether the manifest is valid
+ * @property {string[]} errors - Array of error messages
+ * @property {string[]} warnings - Array of warning messages
+ * @property {string[]} info - Array of info messages
+ */
+
+/**
+ * Validate a value against a schema property
+ * @private
+ * @param {*} value - The value to validate
+ * @param {Object} propSchema - The property schema
+ * @param {string} path - The current path in the object
+ * @returns {string[]} Array of error messages
+ */
+function validateProperty(value, propSchema, path) {
+  const errors = [];
+
+  if (value === undefined) {
+    // Check if required (handled at object level)
+    return errors;
+  }
+
+  // Type validation
+  if (propSchema.type) {
+    const actualType = Array.isArray(value) ? 'array' : typeof value;
+    if (actualType !== propSchema.type) {
+      // Special case for numbers (can be strings that parse as numbers)
+      if (propSchema.type === 'number' && !isNaN(Number(value))) {
+        // OK
+      } else {
+        errors.push(`'${path}' must be of type ${propSchema.type}, got ${actualType}`);
+        return errors;
+      }
+    }
+  }
+
+  // String validations
+  if (propSchema.type === 'string' && typeof value === 'string') {
+    if (propSchema.minLength !== undefined && value.length < propSchema.minLength) {
+      errors.push(`'${path}' must be at least ${propSchema.minLength} characters`);
+    }
+    if (propSchema.maxLength !== undefined && value.length > propSchema.maxLength) {
+      errors.push(`'${path}' must be at most ${propSchema.maxLength} characters`);
+    }
+    if (propSchema.pattern) {
+      const regex = new RegExp(propSchema.pattern);
+      if (!regex.test(value)) {
+        errors.push(`'${path}' does not match required pattern: ${propSchema.pattern}`);
+      }
+    }
+    if (propSchema.enum && !propSchema.enum.includes(value)) {
+      errors.push(`'${path}' must be one of: ${propSchema.enum.join(', ')}`);
+    }
+  }
+
+  // Number validations
+  if (propSchema.type === 'number' && typeof value === 'number') {
+    if (propSchema.minimum !== undefined && value < propSchema.minimum) {
+      errors.push(`'${path}' must be at least ${propSchema.minimum}`);
+    }
+    if (propSchema.maximum !== undefined && value > propSchema.maximum) {
+      errors.push(`'${path}' must be at most ${propSchema.maximum}`);
+    }
+  }
+
+  // Array validations
+  if (propSchema.type === 'array' && Array.isArray(value)) {
+    if (propSchema.items) {
+      value.forEach((item, index) => {
+        const itemErrors = validateProperty(item, propSchema.items, `${path}[${index}]`);
+        errors.push(...itemErrors);
+      });
+    }
+    if (propSchema.uniqueItems) {
+      const uniqueSet = new Set(value.map(JSON.stringify));
+      if (uniqueSet.size !== value.length) {
+        errors.push(`'${path}' must have unique items`);
+      }
+    }
+  }
+
+  // Object validations
+  if (propSchema.type === 'object' && typeof value === 'object' && !Array.isArray(value)) {
+    if (propSchema.properties) {
+      for (const [key, subSchema] of Object.entries(propSchema.properties)) {
+        const subErrors = validateProperty(value[key], subSchema, `${path}.${key}`);
+        errors.push(...subErrors);
+      }
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Validate a plugin manifest against the schema
+ * @param {Object} manifest - The parsed plugin.json object
+ * @param {Object} options - Validation options
+ * @param {boolean} options.strict - Whether to fail on unknown properties
+ * @returns {ValidationResult} Validation result
+ */
+export function validateManifest(manifest, options = {}) {
+  const { strict = false } = options;
+  const errors = [];
+  const warnings = [];
+  const info = [];
+
+  if (!manifest || typeof manifest !== 'object') {
+    return {
+      valid: false,
+      errors: ['Manifest must be a valid JSON object'],
+      warnings,
+      info
+    };
+  }
+
+  if (!schema) {
+    return {
+      valid: true,
+      errors: [],
+      warnings: ['Schema not loaded, skipping validation'],
+      info: ['Manifest structure was not validated']
+    };
+  }
+
+  // Check required fields
+  if (schema.required) {
+    for (const field of schema.required) {
+      if (!(field in manifest)) {
+        errors.push(`Missing required field: '${field}'`);
+      }
+    }
+  }
+
+  // Validate properties
+  if (schema.properties) {
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (key in manifest) {
+        const propErrors = validateProperty(manifest[key], propSchema, key);
+        errors.push(...propErrors);
+      }
+    }
+  }
+
+  // Check for unknown properties in strict mode
+  if (strict && schema.additionalProperties === false) {
+    const knownProps = Object.keys(schema.properties || {});
+    for (const key of Object.keys(manifest)) {
+      if (!knownProps.includes(key)) {
+        errors.push(`Unknown property: '${key}'`);
+      }
+    }
+  }
+
+  // Add warnings for deprecated fields
+  if (schema.properties) {
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (propSchema.deprecated && key in manifest) {
+        warnings.push(`Field '${key}' is deprecated: ${propSchema.description}`);
+      }
+    }
+  }
+
+  // Add info messages for optional fields with defaults
+  if (schema.properties) {
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      if (!(key in manifest) && 'default' in propSchema) {
+        info.push(`Using default value for '${key}': ${JSON.stringify(propSchema.default)}`);
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    info
+  };
+}
+
+/**
+ * Validate a plugin manifest from a file path
+ * @param {string} filePath - Path to the plugin.json file
+ * @param {Object} options - Validation options
+ * @returns {ValidationResult} Validation result
+ */
+export function validateManifestFile(filePath, options = {}) {
+  const resolvedPath = resolve(filePath);
+
+  if (!existsSync(resolvedPath)) {
+    return {
+      valid: false,
+      errors: [`File not found: ${resolvedPath}`],
+      warnings: [],
+      info: []
+    };
+  }
+
+  let manifest;
+  try {
+    const content = readFileSync(resolvedPath, 'utf8');
+    manifest = JSON.parse(content);
+  } catch (err) {
+    return {
+      valid: false,
+      errors: [`Failed to parse JSON: ${err.message}`],
+      warnings: [],
+      info: []
+    };
+  }
+
+  return validateManifest(manifest, options);
+}
+
+/**
+ * Format validation results for display
+ * @param {ValidationResult} result - The validation result
+ * @param {string} pluginName - Optional plugin name for context
+ * @returns {string} Formatted output
+ */
+export function formatValidationResult(result, pluginName = '') {
+  const lines = [];
+  const name = pluginName ? ` ${pluginName} ` : '';
+
+  if (result.valid) {
+    lines.push(`✓ Plugin${name}is valid`);
+  } else {
+    lines.push(`✗ Plugin${name}validation failed`);
+  }
+
+  if (result.errors.length > 0) {
+    lines.push('');
+    lines.push('Errors:');
+    result.errors.forEach(err => lines.push(`  • ${err}`));
+  }
+
+  if (result.warnings.length > 0) {
+    lines.push('');
+    lines.push('Warnings:');
+    result.warnings.forEach(warn => lines.push(`  • ${warn}`));
+  }
+
+  if (result.info.length > 0) {
+    lines.push('');
+    lines.push('Info:');
+    result.info.forEach(i => lines.push(`  • ${i}`));
+  }
+
+  return lines.join('\n');
+}
+
+export default {
+  validateManifest,
+  validateManifestFile,
+  formatValidationResult
+};

package/src/retry.js

@@ -0,0 +1,218 @@
+/**
+ * Retry utility for OpenClaw API calls
+ * Implements exponential backoff with configurable options
+ */
+
+import logger from './logger.js';
+import config from './config.js';
+
+// Default retry configuration
+const DEFAULT_OPTIONS = config.DEFAULT_RETRY_OPTIONS;
+
+/**
+ * Sleep for specified milliseconds
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise} Resolves after delay
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Calculate delay with exponential backoff
+ * @param {number} attempt - Current attempt number (0-indexed)
+ * @param {object} options - Retry options
+ * @returns {number} Delay in milliseconds
+ */
+function calculateDelay(attempt, options) {
+  const delay = Math.min(
+    options.initialDelay * Math.pow(options.backoffMultiplier, attempt),
+    options.maxDelay
+  );
+  
+  // Add jitter (±10%) to prevent thundering herd
+  const jitter = delay * 0.1 * (Math.random() * 2 - 1);
+  return Math.floor(delay + jitter);
+}
+
+/**
+ * Check if error is retryable
+ * @param {Error} error - Error object
+ * @param {object} options - Retry options
+ * @returns {boolean} Whether the error is retryable
+ */
+function isRetryableError(error, options) {
+  // Check for retryable error codes
+  if (error.code && options.retryableErrors.includes(error.code)) {
+    return true;
+  }
+  
+  // Check for retryable HTTP status codes (if response exists)
+  if (error.status && options.retryableStatuses.includes(error.status)) {
+    return true;
+  }
+  
+  // Check error message for common retryable patterns
+  const message = error.message || '';
+  const retryablePatterns = [
+    /connection refused/i,
+    /timeout/i,
+    /network/i,
+    /econnreset/i,
+    /eai_again/i,
+    /temporary failure/i,
+    /service unavailable/i,
+    /internal server error/i,
+    /bad gateway/i,
+    /gateway timeout/i,
+  ];
+
+  return retryablePatterns.some(pattern => pattern.test(message));
+}
+
+/**
+ * Wrap a function with retry logic
+ * @param {Function} fn - Function to wrap (must return a Promise)
+ * @param {object} options - Retry options
+ * @returns {Function} Wrapped function
+ */
+function withRetry(fn, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  
+  return async function retryWrapper(...args) {
+    let lastError;
+    
+    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+      try {
+        // Execute the function
+        const result = await fn(...args);
+        
+        // Log successful retry if this wasn't the first attempt
+        if (attempt > 0) {
+          logger.info(`[RETRY] Operation succeeded after ${attempt} retries`);
+        }
+        
+        return result;
+        
+      } catch (error) {
+        lastError = error;
+        
+        // Check if we should retry
+        const isLastAttempt = attempt >= opts.maxRetries;
+        const shouldRetry = !isLastAttempt && isRetryableError(error, opts);
+        
+        if (!shouldRetry) {
+          // Log the final failure
+          logger.error(`[RETRY] Operation failed after ${attempt} attempts: ${error.message}`);
+          throw error;
+        }
+        
+        // Calculate delay and wait
+        const delay = calculateDelay(attempt, opts);
+        logger.warn(`[RETRY] Attempt ${attempt + 1}/${opts.maxRetries + 1} failed: ${error.message}. Retrying in ${Math.round(delay)}ms...`);
+        await sleep(delay);
+      }
+    }
+    
+    // This should never be reached, but just in case
+    throw lastError;
+  };
+}
+
+/**
+ * Retry a function until it succeeds or timeout
+ * @param {Function} fn - Function to retry
+ * @param {number} timeout - Maximum time to keep retrying (ms)
+ * @param {number} interval - Time between retries (ms)
+ * @returns {Promise} Result of function
+ */
+async function retryUntil(fn, timeout = config.RETRY.TIMEOUT, interval = config.RETRY.INTERVAL) {
+  const startTime = Date.now();
+  
+  while (true) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (Date.now() - startTime >= timeout) {
+        throw new Error(`Retry timeout after ${timeout}ms: ${error.message}`);
+      }
+      logger.warn(`[RETRY] Waiting for condition: ${error.message}`);
+      await sleep(interval);
+    }
+  }
+}
+
+/**
+ * Create a retryable HTTP request wrapper
+ * @param {Function} fetchFn - Fetch function (fetch, axios, etc.)
+ * @param {object} options - Retry options
+ * @returns {Function} Wrapped fetch function
+ */
+function createRetryableFetch(fetchFn, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  
+  return async function retryableFetch(url, fetchOptions = {}) {
+    let lastError;
+    
+    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+      try {
+        const response = await fetchFn(url, fetchOptions);
+        
+        // Check if response status is retryable
+        if (opts.retryableStatuses.includes(response.status)) {
+          const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+          error.status = response.status;
+          throw error;
+        }
+        
+        // Return response for non-retryable statuses (caller handles 2xx, 4xx)
+        return response;
+        
+      } catch (error) {
+        lastError = error;
+        
+        // Check if we should retry
+        const isLastAttempt = attempt >= opts.maxRetries;
+        const shouldRetry = !isLastAttempt && isRetryableError(error, opts);
+        
+        if (!shouldRetry) {
+          throw error;
+        }
+        
+        // Calculate delay and wait
+        const delay = calculateDelay(attempt, opts);
+        logger.warn(`[RETRY] HTTP request attempt ${attempt + 1}/${opts.maxRetries + 1} failed: ${error.message}. Retrying in ${Math.round(delay)}ms...`);
+        await sleep(delay);
+      }
+    }
+    
+    throw lastError;
+  };
+}
+
+/**
+ * Batch retry multiple independent operations
+ * @param {Array<Function>} fns - Array of functions to execute
+ * @param {object} options - Retry options
+ * @returns {Promise<Array>} Array of results
+ */
+async function retryBatch(fns, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  
+  // Wrap each function with retry
+  const wrappedFns = fns.map(fn => withRetry(fn, opts));
+  
+  // Execute all in parallel
+  return Promise.allSettled(wrappedFns.map(fn => fn()));
+}
+
+export default {
+  DEFAULT_OPTIONS,
+  withRetry,
+  retryUntil,
+  createRetryableFetch,
+  retryBatch,
+  sleep,
+  calculateDelay,
+  isRetryableError
+};