openclaw-overlay-plugin 0.7.34 → 0.7.35

package/dist/services/built-in/tell-joke/index.js

@@ -1,31 +0,0 @@
-/**
- * Tell Joke service definition.
- *
- * A simple service that tells random jokes. This demonstrates
- * a basic service that works in both handler and agent modes.
- */
-import { ServiceCategory } from '../../types.js';
-import { tellJokeHandler } from './handler.js';
-const tellJokeService = {
-    id: 'tell-joke',
-    name: 'Random Joke',
-    description: 'Get a random joke. Guaranteed to be at least mildly amusing.',
-    defaultPrice: 5,
-    category: ServiceCategory.ENTERTAINMENT,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            topic: {
-                type: 'string',
-                description: 'Optional topic for the joke (e.g., "programming", "cats")'
-            },
-            style: {
-                type: 'string',
-                enum: ['dad', 'pun', 'tech', 'general'],
-                description: 'Style of joke to tell'
-            }
-        }
-    },
-    handler: tellJokeHandler
-};
-export default tellJokeService;

package/dist/services/built-in/translate/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Translation service definition.
- */
-import { ServiceDefinition } from '../../types.js';
-declare const translateService: ServiceDefinition;
-export default translateService;

package/dist/services/built-in/translate/index.js

@@ -1,21 +0,0 @@
-/**
- * Translation service definition.
- */
-import { ServiceCategory } from '../../types.js';
-const translateService = {
-    id: 'translate',
-    name: 'Translation',
-    description: 'Translate text between 30+ languages. Accurate, context-aware translations.',
-    defaultPrice: 20,
-    category: ServiceCategory.UTILITY,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            text: { type: 'string', description: 'Text to translate' },
-            to: { type: 'string', description: 'Target language (e.g., "es", "french", "Japanese")' },
-            from: { type: 'string', description: 'Source language (auto-detected if not provided)' }
-        },
-        required: ['text', 'to']
-    }
-};
-export default translateService;

package/dist/services/built-in/web-research/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Web Research service definition.
- *
- * Research any topic using current web sources and return a synthesized
- * summary with cited sources. Agent-mode service leveraging web search.
- */
-import { ServiceDefinition } from '../../types.js';
-declare const webResearchService: ServiceDefinition;
-export default webResearchService;

package/dist/services/built-in/web-research/index.js

@@ -1,51 +0,0 @@
-/**
- * Web Research service definition.
- *
- * Research any topic using current web sources and return a synthesized
- * summary with cited sources. Agent-mode service leveraging web search.
- */
-import { ServiceCategory } from '../../types.js';
-const webResearchService = {
-    id: 'web-research',
-    name: 'Web Research',
-    description: 'Research any topic using current web sources. Returns a synthesized summary with cited sources.',
-    defaultPrice: 50,
-    category: ServiceCategory.RESEARCH,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            query: {
-                type: 'string',
-                description: 'Research query or topic'
-            },
-            depth: {
-                type: 'string',
-                enum: ['quick', 'standard', 'comprehensive'],
-                description: 'Research depth (default: standard)'
-            },
-            sources: {
-                type: 'number',
-                minimum: 3,
-                maximum: 20,
-                description: 'Number of sources to research (default: 5)'
-            },
-            focusAreas: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Specific aspects to focus on'
-            },
-            excludeDomains: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Domains to exclude from research'
-            },
-            timeframe: {
-                type: 'string',
-                enum: ['day', 'week', 'month', 'year', 'all'],
-                description: 'How recent the information should be'
-            }
-        },
-        required: ['query']
-    }
-};
-export default webResearchService;

package/dist/services/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Service system main exports.
- *
- * This is the main entry point for the service system, providing
- * a clean interface for the rest of the application.
- */
-export * from './types.js';
-export * from './registry.js';
-export * from './loader.js';
-export * from './manager.js';
-export { serviceRegistry } from './registry.js';
-export { serviceLoader } from './loader.js';
-export { serviceManager, initializeServiceSystem, getServiceManager } from './manager.js';

package/dist/services/index.js

@@ -1,14 +0,0 @@
-/**
- * Service system main exports.
- *
- * This is the main entry point for the service system, providing
- * a clean interface for the rest of the application.
- */
-export * from './types.js';
-export * from './registry.js';
-export * from './loader.js';
-export * from './manager.js';
-// Re-export the main instances for easy access
-export { serviceRegistry } from './registry.js';
-export { serviceLoader } from './loader.js';
-export { serviceManager, initializeServiceSystem, getServiceManager } from './manager.js';

package/dist/services/loader.d.ts

@@ -1,77 +0,0 @@
-/**
- * Service loader implementation.
- *
- * This dynamically loads services from directories, supporting both
- * built-in services and custom user services.
- */
-import { ServiceDefinition, ServiceLoader } from './types.js';
-/**
- * Default service loader implementation.
- */
-export declare class DefaultServiceLoader implements ServiceLoader {
-    private builtInDir;
-    private customDir;
-    constructor();
-    /**
-     * Load services from a directory.
-     */
-    loadFromDirectory(directory: string): Promise<ServiceDefinition[]>;
-    /**
-     * Load all built-in services.
-     */
-    loadBuiltInServices(): Promise<ServiceDefinition[]>;
-    /**
-     * Load custom user services.
-     */
-    loadCustomServices(): Promise<ServiceDefinition[]>;
-    /**
-     * Load all services (built-in + custom).
-     */
-    loadAllServices(): Promise<ServiceDefinition[]>;
-    /**
-     * Load a service definition from a directory.
-     */
-    private loadServiceFromDirectory;
-    /**
-     * Create a new custom service directory.
-     */
-    createCustomServiceDirectory(serviceId: string): string;
-    /**
-     * Create a basic service template.
-     */
-    createServiceTemplate(serviceId: string, options: {
-        name: string;
-        description: string;
-        defaultPrice: number;
-        category?: string;
-        hasHandler?: boolean;
-    }): void;
-    /**
-     * Generate service definition template.
-     */
-    private generateServiceTemplate;
-    /**
-     * Generate prompt template.
-     */
-    private generatePromptTemplate;
-    /**
-     * Generate handler template.
-     */
-    private generateHandlerTemplate;
-    /**
-     * Get the built-in services directory.
-     */
-    getBuiltInDirectory(): string;
-    /**
-     * Get the custom services directory.
-     */
-    getCustomDirectory(): string;
-    /**
-     * Check if a service directory exists.
-     */
-    serviceExists(serviceId: string, inCustom?: boolean): boolean;
-}
-/**
- * Global service loader instance.
- */
-export declare const serviceLoader: DefaultServiceLoader;

package/dist/services/loader.js

@@ -1,292 +0,0 @@
-/**
- * Service loader implementation.
- *
- * This dynamically loads services from directories, supporting both
- * built-in services and custom user services.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-/**
- * Default service loader implementation.
- */
-export class DefaultServiceLoader {
-    builtInDir;
-    customDir;
-    constructor() {
-        // Built-in services directory
-        this.builtInDir = path.resolve(__dirname, 'built-in');
-        // Custom services directory (in user's config dir)
-        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-        this.customDir = path.join(homeDir, '.openclaw', 'services');
-    }
-    /**
-     * Load services from a directory.
-     */
-    async loadFromDirectory(directory) {
-        if (!fs.existsSync(directory)) {
-            return [];
-        }
-        const services = [];
-        const entries = fs.readdirSync(directory, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory()) {
-                continue;
-            }
-            try {
-                const serviceDefinition = await this.loadServiceFromDirectory(path.join(directory, entry.name));
-                if (serviceDefinition) {
-                    services.push(serviceDefinition);
-                }
-            }
-            catch (error) {
-                console.warn(`Failed to load service from ${entry.name}:`, error);
-            }
-        }
-        return services;
-    }
-    /**
-     * Load all built-in services.
-     */
-    async loadBuiltInServices() {
-        return this.loadFromDirectory(this.builtInDir);
-    }
-    /**
-     * Load custom user services.
-     */
-    async loadCustomServices() {
-        return this.loadFromDirectory(this.customDir);
-    }
-    /**
-     * Load all services (built-in + custom).
-     */
-    async loadAllServices() {
-        const [builtIn, custom] = await Promise.all([
-            this.loadBuiltInServices(),
-            this.loadCustomServices()
-        ]);
-        return [...builtIn, ...custom];
-    }
-    /**
-     * Load a service definition from a directory.
-     */
-    async loadServiceFromDirectory(serviceDir) {
-        const indexPath = path.join(serviceDir, 'index.ts');
-        const jsIndexPath = path.join(serviceDir, 'index.js');
-        const promptPath = path.join(serviceDir, 'prompt.md');
-        // Check if index file exists (TypeScript or JavaScript)
-        let modulePath;
-        if (fs.existsSync(indexPath)) {
-            modulePath = indexPath;
-        }
-        else if (fs.existsSync(jsIndexPath)) {
-            modulePath = jsIndexPath;
-        }
-        else {
-            throw new Error(`No index.ts or index.js found in ${serviceDir}`);
-        }
-        try {
-            // Dynamic import the service module
-            const serviceModule = await import(modulePath);
-            const serviceDefinition = serviceModule.default || serviceModule;
-            if (!serviceDefinition || typeof serviceDefinition !== 'object') {
-                throw new Error('Service must export a default ServiceDefinition object');
-            }
-            // Validate required fields
-            if (!serviceDefinition.id) {
-                throw new Error('Service definition must have an id');
-            }
-            // Add prompt file path if it exists
-            if (fs.existsSync(promptPath)) {
-                serviceDefinition.promptFile = promptPath;
-            }
-            return serviceDefinition;
-        }
-        catch (error) {
-            throw new Error(`Failed to import service from ${modulePath}: ${error}`);
-        }
-    }
-    /**
-     * Create a new custom service directory.
-     */
-    createCustomServiceDirectory(serviceId) {
-        const serviceDir = path.join(this.customDir, serviceId);
-        // Ensure custom services directory exists
-        fs.mkdirSync(this.customDir, { recursive: true });
-        // Create service directory
-        if (fs.existsSync(serviceDir)) {
-            throw new Error(`Service directory ${serviceId} already exists`);
-        }
-        fs.mkdirSync(serviceDir);
-        return serviceDir;
-    }
-    /**
-     * Create a basic service template.
-     */
-    createServiceTemplate(serviceId, options) {
-        const serviceDir = this.createCustomServiceDirectory(serviceId);
-        // Create index.ts
-        const indexContent = this.generateServiceTemplate(serviceId, options);
-        fs.writeFileSync(path.join(serviceDir, 'index.ts'), indexContent);
-        // Create prompt.md
-        const promptContent = this.generatePromptTemplate(serviceId, options);
-        fs.writeFileSync(path.join(serviceDir, 'prompt.md'), promptContent);
-        // Create handler.ts if requested
-        if (options.hasHandler) {
-            const handlerContent = this.generateHandlerTemplate(serviceId, options);
-            fs.writeFileSync(path.join(serviceDir, 'handler.ts'), handlerContent);
-        }
-    }
-    /**
-     * Generate service definition template.
-     */
-    generateServiceTemplate(serviceId, options) {
-        return `/**
- * ${options.name} service definition.
- */
-
-import { ServiceDefinition${options.hasHandler ? ', ServiceHandler' : ''} } from '../../types.js';
-${options.hasHandler ? `import { ${serviceId.replace(/-/g, '')}Handler } from './handler.js';` : ''}
-
-const ${serviceId.replace(/-/g, '')}Service: ServiceDefinition = {
-  id: '${serviceId}',
-  name: '${options.name}',
-  description: '${options.description}',
-  defaultPrice: ${options.defaultPrice},${options.category ? `\n  category: '${options.category}',` : ''}
-  inputSchema: {
-    type: 'object',
-    properties: {
-      // Define your input schema here
-      query: {
-        type: 'string',
-        description: 'Query or input for the service'
-      }
-    },
-    required: ['query']
-  }${options.hasHandler ? `,\n  handler: ${serviceId.replace(/-/g, '')}Handler` : ''}
-};
-
-export default ${serviceId.replace(/-/g, '')}Service;
-`;
-    }
-    /**
-     * Generate prompt template.
-     */
-    generatePromptTemplate(serviceId, options) {
-        return `# ${options.name} Service
-
-You are processing a request for the "${serviceId}" service.
-
-## Service Description
-${options.description}
-
-## Input
-The user has provided the following input:
-\`\`\`json
-{{input}}
-\`\`\`
-
-## Instructions
-Process the user's request and provide a helpful response based on the service description.
-Format your response as a structured result that can be easily parsed and used.
-
-## Response Format
-Provide your response in this format:
-\`\`\`json
-{
-  "result": "your processed result here",
-  "metadata": {
-    "processingTime": "time taken",
-    "version": "1.0"
-  }
-}
-\`\`\`
-`;
-    }
-    /**
-     * Generate handler template.
-     */
-    generateHandlerTemplate(serviceId, options) {
-        return `/**
- * ${options.name} service handler.
- */
-
-import { ServiceHandler, ValidationResult, ServiceContext, ServiceResult } from '../../types.js';
-
-export const ${serviceId.replace(/-/g, '')}Handler: ServiceHandler = {
-  /**
-   * Validate service input.
-   */
-  validate(input: any): ValidationResult {
-    if (!input || typeof input !== 'object') {
-      return { valid: false, error: 'Input must be an object' };
-    }
-
-    if (!input.query || typeof input.query !== 'string') {
-      return { valid: false, error: 'Query must be a non-empty string' };
-    }
-
-    // Add more validation as needed
-    return { valid: true, sanitized: input };
-  },
-
-  /**
-   * Process the service request.
-   */
-  async process(input: any, context: ServiceContext): Promise<ServiceResult> {
-    try {
-      const startTime = Date.now();
-
-      // Your service logic here
-      const result = {
-        query: input.query,
-        response: 'This is a template response. Implement your logic here.',
-        timestamp: new Date().toISOString()
-      };
-
-      const processingTime = Date.now() - startTime;
-
-      return {
-        success: true,
-        data: result,
-        metadata: {
-          processingTime,
-          version: '1.0'
-        }
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-};
-`;
-    }
-    /**
-     * Get the built-in services directory.
-     */
-    getBuiltInDirectory() {
-        return this.builtInDir;
-    }
-    /**
-     * Get the custom services directory.
-     */
-    getCustomDirectory() {
-        return this.customDir;
-    }
-    /**
-     * Check if a service directory exists.
-     */
-    serviceExists(serviceId, inCustom = false) {
-        const baseDir = inCustom ? this.customDir : this.builtInDir;
-        return fs.existsSync(path.join(baseDir, serviceId));
-    }
-}
-/**
- * Global service loader instance.
- */
-export const serviceLoader = new DefaultServiceLoader();

package/dist/services/manager.d.ts

@@ -1,86 +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 { ServiceManager, ServiceDefinition, ServiceContext, ServiceResult, ValidationResult } from './types.js';
-import { DefaultServiceRegistry } from './registry.js';
-import { DefaultServiceLoader } from './loader.js';
-/**
- * Default service manager implementation.
- */
-export declare class DefaultServiceManager implements ServiceManager {
-    readonly registry: DefaultServiceRegistry;
-    readonly loader: DefaultServiceLoader;
-    private initialized;
-    constructor();
-    /**
-     * Initialize the service system.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Execute a service request.
-     */
-    execute(serviceId: string, input: any, context: ServiceContext): Promise<ServiceResult>;
-    /**
-     * Validate service input.
-     */
-    validate(serviceId: string, input: any): ValidationResult;
-    /**
-     * Reload all services.
-     */
-    reload(): Promise<void>;
-    /**
-     * Get service for agent-mode processing.
-     */
-    getServiceForAgentMode(serviceId: string): {
-        service: ServiceDefinition;
-        promptFile?: string;
-    } | null;
-    /**
-     * Check if service is available.
-     */
-    isServiceAvailable(serviceId: string): boolean;
-    /**
-     * Get service execution mode.
-     */
-    getServiceMode(serviceId: string): 'handler' | 'agent' | null;
-    /**
-     * Get all available services for discovery.
-     */
-    getAvailableServices(): Array<{
-        id: string;
-        name: string;
-        description: string;
-        defaultPrice: number;
-        category?: string;
-        mode: 'handler' | 'agent';
-    }>;
-    /**
-     * Validate input against JSON schema.
-     */
-    private validateAgainstSchema;
-    /**
-     * Get service statistics.
-     */
-    getStatistics(): {
-        totalServices: number;
-        handlerServices: number;
-        agentServices: number;
-        servicesByCategory: Record<string, number>;
-    };
-}
-/**
- * Global service manager instance.
- */
-export declare const serviceManager: DefaultServiceManager;
-/**
- * Initialize the service system.
- * This should be called once during application startup.
- */
-export declare function initializeServiceSystem(): Promise<void>;
-/**
- * Get service manager instance.
- */
-export declare function getServiceManager(): DefaultServiceManager;