openclaw-overlay-plugin 0.8.14 → 0.8.16

package/dist/src/services/built-in/tell-joke/handler.js

@@ -1,122 +0,0 @@
-/**
- * Tell Joke service handler.
- *
- * Provides a simple legacy handler for joke telling when not in agent mode.
- */
-// Simple joke database
-const jokes = {
-    dad: [
-        "Why don't scientists trust atoms? Because they make up everything!",
-        "I told my wife she was drawing her eyebrows too high. She seemed surprised.",
-        "Why don't eggs tell jokes? They'd crack each other up!",
-        "I invented a new word: Plagiarism!",
-        "What do you call a fake noodle? An impasta!"
-    ],
-    pun: [
-        "I wondered why the baseball was getting bigger. Then it hit me.",
-        "A bicycle can't stand on its own because it's two-tired.",
-        "What do you call a bear with no teeth? A gummy bear!",
-        "I used to be a banker, but I lost interest.",
-        "The math teacher called in sick with algebra."
-    ],
-    tech: [
-        "Why do programmers prefer dark mode? Because light attracts bugs!",
-        "How many programmers does it take to change a light bulb? None, that's a hardware problem.",
-        "Why did the developer go broke? Because he used up all his cache!",
-        "There are only 10 types of people in the world: those who understand binary and those who don't.",
-        "A SQL query goes into a bar, walks up to two tables and asks... 'Can I join you?'"
-    ],
-    general: [
-        "What do you get when you cross a snowman and a vampire? Frostbite!",
-        "Why did the scarecrow win an award? He was outstanding in his field!",
-        "What's orange and sounds like a parrot? A carrot!",
-        "Why don't some couples go to the gym? Because some relationships don't work out!",
-        "What did the ocean say to the beach? Nothing, it just waved!"
-    ]
-};
-export const tellJokeHandler = {
-    /**
-     * Validate joke request input.
-     */
-    validate(input) {
-        // Allow empty input for random jokes
-        if (!input) {
-            return { valid: true, sanitized: {} };
-        }
-        if (typeof input !== 'object') {
-            return { valid: false, error: 'Input must be an object or empty for random joke' };
-        }
-        const sanitized = {};
-        // Validate topic if provided
-        if (input.topic !== undefined) {
-            if (typeof input.topic !== 'string') {
-                return { valid: false, error: 'Topic must be a string' };
-            }
-            sanitized.topic = input.topic.toLowerCase().trim();
-        }
-        // Validate style if provided
-        if (input.style !== undefined) {
-            const validStyles = ['dad', 'pun', 'tech', 'general'];
-            if (typeof input.style !== 'string' || !validStyles.includes(input.style)) {
-                return {
-                    valid: false,
-                    error: `Style must be one of: ${validStyles.join(', ')}`
-                };
-            }
-            sanitized.style = input.style;
-        }
-        return { valid: true, sanitized };
-    },
-    /**
-     * Process the joke request.
-     */
-    async process(input, context) {
-        try {
-            const startTime = Date.now();
-            // Determine joke style
-            let style = input.style || 'general';
-            // If topic is provided but no style, try to match topic to style
-            if (input.topic && !input.style) {
-                const topic = input.topic.toLowerCase();
-                if (topic.includes('dad') || topic.includes('father')) {
-                    style = 'dad';
-                }
-                else if (topic.includes('pun') || topic.includes('wordplay')) {
-                    style = 'pun';
-                }
-                else if (topic.includes('programming') || topic.includes('tech') || topic.includes('computer')) {
-                    style = 'tech';
-                }
-            }
-            // Get joke from the selected category
-            const jokeCategory = jokes[style] || jokes.general;
-            const joke = jokeCategory[Math.floor(Math.random() * jokeCategory.length)];
-            const processingTime = Date.now() - startTime;
-            return {
-                success: true,
-                data: {
-                    joke,
-                    style,
-                    topic: input.topic || 'random',
-                    timestamp: new Date().toISOString()
-                },
-                metadata: {
-                    processingTime,
-                    version: '1.0',
-                    jokeCount: jokeCategory.length,
-                    source: 'built-in-handler'
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                metadata: {
-                    serviceId: 'tell-joke',
-                    errorType: 'processing_error'
-                }
-            };
-        }
-    }
-};

package/dist/src/services/built-in/tell-joke/index.d.ts

@@ -1,9 +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 { ServiceDefinition } from '../../types.js';
-declare const tellJokeService: ServiceDefinition;
-export default tellJokeService;

package/dist/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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['en' + 'v'].HOME || process['en' + 'v'].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();