openclaw-overlay-plugin 0.8.15 → 0.8.17

package/dist/src/services/manager.js

@@ -1,255 +0,0 @@
-/**
- * Service manager implementation.
- *
- * This orchestrates the service system, providing a high-level interface
- * for service execution while keeping payment and relay logic separate.
- */
-import { serviceRegistry } from './registry.js';
-import { serviceLoader } from './loader.js';
-/**
- * Default service manager implementation.
- */
-export class DefaultServiceManager {
-    registry;
-    loader;
-    initialized = false;
-    constructor() {
-        this.registry = serviceRegistry;
-        this.loader = serviceLoader;
-    }
-    /**
-     * Initialize the service system.
-     */
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        // Load all services
-        const services = await this.loader.loadAllServices();
-        // Register all services
-        for (const service of services) {
-            try {
-                this.registry.register(service);
-            }
-            catch (error) {
-                console.warn(`Failed to register service '${service.id}':`, error);
-            }
-        }
-        this.initialized = true;
-        console.log(`Service manager initialized with ${this.registry.count()} services`);
-    }
-    /**
-     * Execute a service request.
-     */
-    async execute(serviceId, input, context) {
-        if (!this.initialized) {
-            throw new Error('Service manager not initialized');
-        }
-        const service = this.registry.get(serviceId);
-        if (!service) {
-            return {
-                success: false,
-                error: `Service '${serviceId}' not found`
-            };
-        }
-        // Validate input if service has a handler
-        if (service.handler) {
-            const validation = service.handler.validate(input);
-            if (!validation.valid) {
-                return {
-                    success: false,
-                    error: `Input validation failed: ${validation.error}`
-                };
-            }
-            // Use sanitized input if provided
-            input = validation.sanitized || input;
-        }
-        // Execute the service
-        try {
-            if (service.handler) {
-                // Use custom handler
-                return await service.handler.process(input, context);
-            }
-            else {
-                // Service uses agent mode - return success with input for agent processing
-                return {
-                    success: true,
-                    data: {
-                        serviceId,
-                        input,
-                        mode: 'agent',
-                        promptFile: service.promptFile
-                    },
-                    metadata: {
-                        version: '1.0',
-                        executionMode: 'agent'
-                    }
-                };
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                metadata: {
-                    serviceId,
-                    errorType: 'execution_error'
-                }
-            };
-        }
-    }
-    /**
-     * Validate service input.
-     */
-    validate(serviceId, input) {
-        const service = this.registry.get(serviceId);
-        if (!service) {
-            return {
-                valid: false,
-                error: `Service '${serviceId}' not found`
-            };
-        }
-        // Use service handler validation if available
-        if (service.handler) {
-            return service.handler.validate(input);
-        }
-        // Default validation for agent-mode services
-        if (service.inputSchema) {
-            return this.validateAgainstSchema(input, service.inputSchema);
-        }
-        // No validation required
-        return { valid: true };
-    }
-    /**
-     * Reload all services.
-     */
-    async reload() {
-        // Clear existing services
-        this.registry.clear();
-        this.initialized = false;
-        // Reinitialize
-        await this.initialize();
-    }
-    /**
-     * Get service for agent-mode processing.
-     */
-    getServiceForAgentMode(serviceId) {
-        const service = this.registry.get(serviceId);
-        if (!service) {
-            return null;
-        }
-        return {
-            service,
-            promptFile: service.promptFile
-        };
-    }
-    /**
-     * Check if service is available.
-     */
-    isServiceAvailable(serviceId) {
-        return this.registry.has(serviceId);
-    }
-    /**
-     * Get service execution mode.
-     */
-    getServiceMode(serviceId) {
-        const service = this.registry.get(serviceId);
-        if (!service) {
-            return null;
-        }
-        return service.handler ? 'handler' : 'agent';
-    }
-    /**
-     * Get all available services for discovery.
-     */
-    getAvailableServices() {
-        return this.registry.list().map(service => ({
-            id: service.id,
-            name: service.name,
-            description: service.description,
-            defaultPrice: service.defaultPrice,
-            category: service.category,
-            mode: service.handler ? 'handler' : 'agent'
-        }));
-    }
-    /**
-     * Validate input against JSON schema.
-     */
-    validateAgainstSchema(input, schema) {
-        // Simple schema validation - in production, you might use a library like ajv
-        try {
-            const schemaObj = schema;
-            if (schemaObj.type === 'object') {
-                if (!input || typeof input !== 'object') {
-                    return { valid: false, error: 'Input must be an object' };
-                }
-                // Check required properties
-                if (schemaObj.required && Array.isArray(schemaObj.required)) {
-                    for (const requiredProp of schemaObj.required) {
-                        if (!(requiredProp in input)) {
-                            return { valid: false, error: `Missing required property: ${requiredProp}` };
-                        }
-                    }
-                }
-                // Basic type checking for properties
-                if (schemaObj.properties) {
-                    for (const [propName, propSchema] of Object.entries(schemaObj.properties)) {
-                        if (propName in input) {
-                            const propType = propSchema.type;
-                            const actualType = typeof input[propName];
-                            if (propType && propType !== actualType) {
-                                return { valid: false, error: `Property '${propName}' must be of type ${propType}` };
-                            }
-                        }
-                    }
-                }
-            }
-            return { valid: true, sanitized: input };
-        }
-        catch (error) {
-            return { valid: false, error: `Schema validation error: ${error}` };
-        }
-    }
-    /**
-     * Get service statistics.
-     */
-    getStatistics() {
-        const services = this.registry.list();
-        const stats = {
-            totalServices: services.length,
-            handlerServices: 0,
-            agentServices: 0,
-            servicesByCategory: {}
-        };
-        for (const service of services) {
-            // Count by execution mode
-            if (service.handler) {
-                stats.handlerServices++;
-            }
-            else {
-                stats.agentServices++;
-            }
-            // Count by category
-            const category = service.category || 'uncategorized';
-            stats.servicesByCategory[category] = (stats.servicesByCategory[category] || 0) + 1;
-        }
-        return stats;
-    }
-}
-/**
- * Global service manager instance.
- */
-export const serviceManager = new DefaultServiceManager();
-/**
- * Initialize the service system.
- * This should be called once during application startup.
- */
-export async function initializeServiceSystem() {
-    await serviceManager.initialize();
-}
-/**
- * Get service manager instance.
- */
-export function getServiceManager() {
-    return serviceManager;
-}

package/dist/src/services/registry.d.ts

@@ -1,98 +0,0 @@
-/**
- * Service registry implementation.
- *
- * This provides a centralized registry for all services, allowing
- * dynamic registration and discovery without modifying core code.
- */
-import { ServiceDefinition, ServiceRegistry } from './types.js';
-/**
- * Default service registry implementation.
- */
-export declare class DefaultServiceRegistry implements ServiceRegistry {
-    private services;
-    /**
-     * Register a new service definition.
-     */
-    register(service: ServiceDefinition): void;
-    /**
-     * Get a service definition by ID.
-     */
-    get(serviceId: string): ServiceDefinition | undefined;
-    /**
-     * List all registered services.
-     */
-    list(): ServiceDefinition[];
-    /**
-     * List services by category.
-     */
-    listByCategory(category: string): ServiceDefinition[];
-    /**
-     * Check if a service is registered.
-     */
-    has(serviceId: string): boolean;
-    /**
-     * Unregister a service.
-     */
-    unregister(serviceId: string): void;
-    /**
-     * Clear all services (useful for testing).
-     */
-    clear(): void;
-    /**
-     * Get service count.
-     */
-    count(): number;
-    /**
-     * Get services by price range.
-     */
-    getByPriceRange(minPrice: number, maxPrice: number): ServiceDefinition[];
-    /**
-     * Search services by name or description.
-     */
-    search(query: string): ServiceDefinition[];
-    /**
-     * Validate a service definition.
-     */
-    private validateServiceDefinition;
-}
-/**
- * Global service registry instance.
- */
-export declare const serviceRegistry: DefaultServiceRegistry;
-/**
- * Utility functions for working with the service registry.
- */
-export declare const ServiceRegistryUtils: {
-    /**
-     * Register multiple services at once.
-     */
-    registerMultiple(services: ServiceDefinition[]): void;
-    /**
-     * Get services that support a specific input type.
-     */
-    getServicesForInput(inputType: string): ServiceDefinition[];
-    /**
-     * Validate service exists and return it.
-     */
-    requireService(serviceId: string): ServiceDefinition;
-    /**
-     * Get all service IDs.
-     */
-    getAllServiceIds(): string[];
-    /**
-     * Check if any services are registered.
-     */
-    hasAnyServices(): boolean;
-    /**
-     * Get service statistics.
-     */
-    getStatistics(): {
-        totalServices: number;
-        servicesByCategory: Record<string, number>;
-        priceRange: {
-            min: number;
-            max: number;
-        };
-        servicesWithHandlers: number;
-    };
-};

package/dist/src/services/registry.js

@@ -1,204 +0,0 @@
-/**
- * Service registry implementation.
- *
- * This provides a centralized registry for all services, allowing
- * dynamic registration and discovery without modifying core code.
- */
-import { ServiceCategory } from './types.js';
-/**
- * Default service registry implementation.
- */
-export class DefaultServiceRegistry {
-    services = new Map();
-    /**
-     * Register a new service definition.
-     */
-    register(service) {
-        // Validate service definition
-        this.validateServiceDefinition(service);
-        // Check for duplicates
-        if (this.services.has(service.id)) {
-            throw new Error(`Service '${service.id}' is already registered`);
-        }
-        // Register the service
-        this.services.set(service.id, { ...service });
-    }
-    /**
-     * Get a service definition by ID.
-     */
-    get(serviceId) {
-        return this.services.get(serviceId);
-    }
-    /**
-     * List all registered services.
-     */
-    list() {
-        return Array.from(this.services.values());
-    }
-    /**
-     * List services by category.
-     */
-    listByCategory(category) {
-        return this.list().filter(service => service.category === category);
-    }
-    /**
-     * Check if a service is registered.
-     */
-    has(serviceId) {
-        return this.services.has(serviceId);
-    }
-    /**
-     * Unregister a service.
-     */
-    unregister(serviceId) {
-        this.services.delete(serviceId);
-    }
-    /**
-     * Clear all services (useful for testing).
-     */
-    clear() {
-        this.services.clear();
-    }
-    /**
-     * Get service count.
-     */
-    count() {
-        return this.services.size;
-    }
-    /**
-     * Get services by price range.
-     */
-    getByPriceRange(minPrice, maxPrice) {
-        return this.list().filter(service => service.defaultPrice >= minPrice && service.defaultPrice <= maxPrice);
-    }
-    /**
-     * Search services by name or description.
-     */
-    search(query) {
-        const lowerQuery = query.toLowerCase();
-        return this.list().filter(service => service.name.toLowerCase().includes(lowerQuery) ||
-            service.description.toLowerCase().includes(lowerQuery) ||
-            service.id.toLowerCase().includes(lowerQuery));
-    }
-    /**
-     * Validate a service definition.
-     */
-    validateServiceDefinition(service) {
-        if (!service.id) {
-            throw new Error('Service ID is required');
-        }
-        if (typeof service.id !== 'string' || service.id.trim().length === 0) {
-            throw new Error('Service ID must be a non-empty string');
-        }
-        // Validate ID format (kebab-case)
-        if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(service.id)) {
-            throw new Error('Service ID must be in kebab-case format (lowercase, hyphens only)');
-        }
-        if (!service.name || typeof service.name !== 'string' || service.name.trim().length === 0) {
-            throw new Error('Service name is required and must be a non-empty string');
-        }
-        if (!service.description || typeof service.description !== 'string' || service.description.trim().length === 0) {
-            throw new Error('Service description is required and must be a non-empty string');
-        }
-        if (typeof service.defaultPrice !== 'number' || service.defaultPrice < 0 || !Number.isInteger(service.defaultPrice)) {
-            throw new Error('Service defaultPrice must be a non-negative integer');
-        }
-        if (service.category && !Object.values(ServiceCategory).includes(service.category)) {
-            throw new Error(`Invalid service category: ${service.category}`);
-        }
-        // Validate input schema if provided
-        if (service.inputSchema && typeof service.inputSchema !== 'object') {
-            throw new Error('Service inputSchema must be an object');
-        }
-        // Validate handler if provided
-        if (service.handler) {
-            if (typeof service.handler.validate !== 'function') {
-                throw new Error('Service handler must have a validate function');
-            }
-            if (typeof service.handler.process !== 'function') {
-                throw new Error('Service handler must have a process function');
-            }
-        }
-    }
-}
-/**
- * Global service registry instance.
- */
-export const serviceRegistry = new DefaultServiceRegistry();
-/**
- * Utility functions for working with the service registry.
- */
-export const ServiceRegistryUtils = {
-    /**
-     * Register multiple services at once.
-     */
-    registerMultiple(services) {
-        for (const service of services) {
-            serviceRegistry.register(service);
-        }
-    },
-    /**
-     * Get services that support a specific input type.
-     */
-    getServicesForInput(inputType) {
-        return serviceRegistry.list().filter(service => {
-            if (!service.inputSchema)
-                return false;
-            const schema = service.inputSchema;
-            return schema.properties && schema.properties[inputType];
-        });
-    },
-    /**
-     * Validate service exists and return it.
-     */
-    requireService(serviceId) {
-        const service = serviceRegistry.get(serviceId);
-        if (!service) {
-            throw new Error(`Service '${serviceId}' not found`);
-        }
-        return service;
-    },
-    /**
-     * Get all service IDs.
-     */
-    getAllServiceIds() {
-        return serviceRegistry.list().map(service => service.id);
-    },
-    /**
-     * Check if any services are registered.
-     */
-    hasAnyServices() {
-        return serviceRegistry.count() > 0;
-    },
-    /**
-     * Get service statistics.
-     */
-    getStatistics() {
-        const services = serviceRegistry.list();
-        const servicesByCategory = {};
-        let minPrice = Infinity;
-        let maxPrice = -Infinity;
-        let servicesWithHandlers = 0;
-        for (const service of services) {
-            // Count by category
-            const category = service.category || 'uncategorized';
-            servicesByCategory[category] = (servicesByCategory[category] || 0) + 1;
-            // Track price range
-            minPrice = Math.min(minPrice, service.defaultPrice);
-            maxPrice = Math.max(maxPrice, service.defaultPrice);
-            // Count services with handlers
-            if (service.handler) {
-                servicesWithHandlers++;
-            }
-        }
-        return {
-            totalServices: services.length,
-            servicesByCategory,
-            priceRange: {
-                min: minPrice === Infinity ? 0 : minPrice,
-                max: maxPrice === -Infinity ? 0 : maxPrice
-            },
-            servicesWithHandlers
-        };
-    }
-};