openclaw-overlay-plugin 0.8.14 → 0.8.16

package/dist/src/test/request-response-flow.test.js

@@ -1,210 +0,0 @@
-/**
- * Tests for request/response flow and duplicate prevention.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-// Simple test runner (matching existing pattern)
-let passed = 0;
-let failed = 0;
-function test(name, fn) {
-    return (async () => {
-        try {
-            await fn();
-            console.log(`  ✓ ${name}`);
-            passed++;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.log(`  ✗ ${name}`);
-            console.log(`    ${msg}`);
-            failed++;
-        }
-    })();
-}
-function assert(condition, message) {
-    if (!condition)
-        throw new Error(`Assertion failed: ${message}`);
-}
-// Mock paths for testing
-const TEST_DIR = path.join(process.cwd(), 'test-data');
-const TEST_PATHS = {
-    serviceQueue: path.join(TEST_DIR, 'service-queue.jsonl'),
-    walletDir: path.join(TEST_DIR, 'wallet'),
-    registration: path.join(TEST_DIR, 'registration.json'),
-    services: path.join(TEST_DIR, 'services.json'),
-};
-function setupTestEnv() {
-    // Setup test directory
-    if (fs.existsSync(TEST_DIR)) {
-        fs.rmSync(TEST_DIR, { recursive: true, force: true });
-    }
-    fs.mkdirSync(TEST_DIR, { recursive: true });
-}
-function cleanupTestEnv() {
-    if (fs.existsSync(TEST_DIR)) {
-        fs.rmSync(TEST_DIR, { recursive: true, force: true });
-    }
-}
-async function run() {
-    console.log('\nRequest/Response Flow Tests\n');
-    // ── Queue Cleanup Tests ──────────────────────────────────────────────
-    await test('cleanupServiceQueue removes old fulfilled entries', async () => {
-        setupTestEnv();
-        const now = Date.now();
-        const oldTime = now - (3 * 60 * 60 * 1000); // 3 hours ago
-        const recentTime = now - (30 * 60 * 1000); // 30 minutes ago
-        // Add test entries
-        const entries = [
-            { status: 'pending', requestId: 'pending-1', _ts: recentTime },
-            { status: 'fulfilled', requestId: 'old-fulfilled', _ts: oldTime },
-            { status: 'fulfilled', requestId: 'recent-fulfilled', _ts: recentTime },
-            { status: 'rejected', requestId: 'old-rejected', _ts: oldTime }
-        ];
-        const content = entries.map(e => JSON.stringify(e)).join('\n') + '\n';
-        fs.writeFileSync(TEST_PATHS.serviceQueue, content);
-        // Mock PATHS for cleanupServiceQueue
-        const originalPaths = await import('../scripts/config.js');
-        const mockPaths = { ...originalPaths.PATHS, serviceQueue: TEST_PATHS.serviceQueue };
-        // Temporarily replace PATHS
-        globalThis.mockPaths = mockPaths;
-        // Redefine cleanupServiceQueue with mocked paths
-        function mockCleanupServiceQueue(maxAgeMs = 24 * 60 * 60 * 1000, finalStatusMaxAgeMs = 2 * 60 * 60 * 1000) {
-            if (!fs.existsSync(TEST_PATHS.serviceQueue))
-                return;
-            const currentTime = Date.now();
-            const finalStatuses = ['fulfilled', 'rejected', 'delivery_failed', 'failed', 'error'];
-            const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
-            const keptLines = [];
-            let removedCount = 0;
-            for (const line of lines) {
-                try {
-                    const entry = JSON.parse(line);
-                    const entryAge = currentTime - (entry._ts || 0);
-                    // Always keep pending entries that aren't too old
-                    if (entry.status === 'pending' && entryAge < maxAgeMs) {
-                        keptLines.push(line);
-                        continue;
-                    }
-                    // Keep final status entries only if they're recent
-                    if (finalStatuses.includes(entry.status) && entryAge < finalStatusMaxAgeMs) {
-                        keptLines.push(line);
-                        continue;
-                    }
-                    // Remove this entry
-                    removedCount++;
-                }
-                catch {
-                    // Keep malformed entries to avoid data loss
-                    keptLines.push(line);
-                }
-            }
-            if (removedCount > 0) {
-                fs.writeFileSync(TEST_PATHS.serviceQueue, keptLines.join('\n') + (keptLines.length ? '\n' : ''));
-            }
-        }
-        // Run cleanup with 2 hour limit for final statuses
-        mockCleanupServiceQueue(24 * 60 * 60 * 1000, 2 * 60 * 60 * 1000);
-        // Check remaining entries
-        const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
-        const remaining = lines.map((line) => JSON.parse(line));
-        assert(remaining.length === 2, `Expected 2 remaining entries, got ${remaining.length}`);
-        assert(remaining.find((e) => e.requestId === 'pending-1') !== undefined, 'Should keep recent pending');
-        assert(remaining.find((e) => e.requestId === 'recent-fulfilled') !== undefined, 'Should keep recent fulfilled');
-        assert(remaining.find((e) => e.requestId === 'old-fulfilled') === undefined, 'Should remove old fulfilled');
-        assert(remaining.find((e) => e.requestId === 'old-rejected') === undefined, 'Should remove old rejected');
-        cleanupTestEnv();
-    });
-    await test('updateServiceQueueStatus updates request status atomically', async () => {
-        setupTestEnv();
-        // Add a test entry
-        const entry = {
-            status: 'pending',
-            requestId: 'test-request-456',
-            serviceId: 'test-service',
-            from: 'sender-key',
-            _ts: Date.now()
-        };
-        fs.writeFileSync(TEST_PATHS.serviceQueue, JSON.stringify(entry) + '\n');
-        // Mock updateServiceQueueStatus with test paths
-        function mockUpdateServiceQueueStatus(requestId, newStatus, additionalFields = {}) {
-            if (!fs.existsSync(TEST_PATHS.serviceQueue))
-                return false;
-            const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
-            let updated = false;
-            const updatedLines = lines.map((line) => {
-                try {
-                    const entryData = JSON.parse(line);
-                    if (entryData.requestId === requestId) {
-                        updated = true;
-                        return JSON.stringify({
-                            ...entryData,
-                            status: newStatus,
-                            ...additionalFields,
-                            updatedAt: Date.now()
-                        });
-                    }
-                    return line;
-                }
-                catch {
-                    return line;
-                }
-            });
-            if (updated) {
-                fs.writeFileSync(TEST_PATHS.serviceQueue, updatedLines.join('\n') + '\n');
-            }
-            return updated;
-        }
-        // Update status
-        const updated = mockUpdateServiceQueueStatus('test-request-456', 'fulfilled', {
-            fulfilledAt: Date.now(),
-            result: { message: 'success' }
-        });
-        assert(updated === true, 'Should return true for successful update');
-        // Verify update
-        const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
-        const updatedEntry = JSON.parse(lines[0]);
-        assert(updatedEntry.status === 'fulfilled', 'Status should be updated to fulfilled');
-        assert(updatedEntry.requestId === 'test-request-456', 'Request ID should remain the same');
-        assert(updatedEntry.fulfilledAt !== undefined, 'Should have fulfilledAt timestamp');
-        assert(updatedEntry.updatedAt !== undefined, 'Should have updatedAt timestamp');
-        assert(updatedEntry.result?.message === 'success', 'Should have result data');
-        cleanupTestEnv();
-    });
-    await test('updateServiceQueueStatus returns false for non-existent request', async () => {
-        setupTestEnv();
-        // Mock updateServiceQueueStatus with test paths
-        function mockUpdateServiceQueueStatus(requestId, _newStatus) {
-            if (!fs.existsSync(TEST_PATHS.serviceQueue))
-                return false;
-            const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
-            let updated = false;
-            lines.map((line) => {
-                try {
-                    const entry = JSON.parse(line);
-                    if (entry.requestId === requestId) {
-                        updated = true;
-                    }
-                    return line;
-                }
-                catch {
-                    return line;
-                }
-            });
-            return updated;
-        }
-        const updated = mockUpdateServiceQueueStatus('non-existent-request', 'fulfilled');
-        assert(updated === false, 'Should return false for non-existent request');
-        cleanupTestEnv();
-    });
-    // ── Summary ──────────────────────────────────────────────────────────
-    console.log(`\n${passed} passed, ${failed} failed\n`);
-    if (failed > 0) {
-        process.exit(1);
-    }
-}
-// Run tests if this file is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-    run().catch(console.error);
-}
-export { run };

package/dist/src/test/service-system.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Service system comprehensive tests.
- * Tests service registration, loading, validation, and execution.
- */
-export {};

package/dist/src/test/service-system.test.js

@@ -1,190 +0,0 @@
-/**
- * Service system comprehensive tests.
- * Tests service registration, loading, validation, and execution.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { serviceRegistry, serviceLoader, serviceManager, initializeServiceSystem } from '../services/index.js';
-import { ServiceCategory } from '../services/types.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const projectRoot = path.resolve(__dirname, '..', '..');
-// Test helper functions
-function assert(condition, message) {
-    if (!condition) {
-        throw new Error(`Assertion failed: ${message}`);
-    }
-}
-function assertEquals(actual, expected, message) {
-    if (actual !== expected) {
-        throw new Error(`Assertion failed: ${message || ''} - Expected ${expected}, got ${actual}`);
-    }
-}
-console.log('\n=== Service System Tests ===\n');
-// Test 1: Service Registry Basic Operations
-console.log('Testing service registry basic operations...');
-// Create test service
-const testService = {
-    id: 'test-service',
-    name: 'Test Service',
-    description: 'A test service for unit testing',
-    defaultPrice: 10,
-    category: ServiceCategory.UTILITY,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            message: { type: 'string', description: 'Test message' }
-        },
-        required: ['message']
-    }
-};
-// Clear registry for clean test
-serviceRegistry.clear();
-// Test registration
-serviceRegistry.register(testService);
-assert(serviceRegistry.get('test-service') !== undefined, 'Service should be registered');
-assertEquals(serviceRegistry.get('test-service')?.name, 'Test Service', 'Service name should match');
-// Test listing
-const services = serviceRegistry.list();
-assert(services.length === 1, 'Should have one registered service');
-assertEquals(services[0].id, 'test-service', 'Listed service should match registered service');
-console.log('✅ Registry: basic operations work correctly');
-// Test 2: Service Registry Validation
-console.log('Testing service registry validation...');
-// Test duplicate registration
-try {
-    serviceRegistry.register(testService);
-    throw new Error('Should have thrown error for duplicate registration');
-}
-catch (error) {
-    assert(error.message.includes('already registered'), 'Should reject duplicate registration');
-}
-// Test invalid service (missing required fields)
-try {
-    serviceRegistry.register({
-        id: '',
-        name: 'Invalid',
-        description: 'Missing ID',
-        defaultPrice: 10
-    });
-    throw new Error('Should have thrown error for invalid service');
-}
-catch (error) {
-    assert(error.message.includes('Service ID is required'), 'Should reject service without ID');
-}
-console.log('✅ Registry: validation works correctly');
-// Test 3: Service Loader Directory Scanning
-console.log('Testing service loader directory scanning...');
-// Clear registry for clean test
-serviceRegistry.clear();
-// Load built-in services
-const builtInServices = await serviceLoader.loadBuiltInServices();
-assert(builtInServices.length > 0, 'Should load built-in services');
-// Check that specific services are loaded
-const expectedServices = ['tell-joke', 'api-proxy', 'summarize', 'memory-store', 'roulette', 'code-develop', 'image-analysis'];
-for (const serviceId of expectedServices) {
-    const service = builtInServices.find(s => s.id === serviceId);
-    assert(service !== undefined, `Should load ${serviceId} service`);
-    assert(service.name.length > 0, `${serviceId} should have a name`);
-    assert(service.description.length > 0, `${serviceId} should have a description`);
-    assert(service.defaultPrice > 0, `${serviceId} should have a valid price`);
-}
-console.log('✅ Loader: directory scanning works correctly');
-// Test 4: Service Manager Integration
-console.log('Testing service manager integration...');
-// Initialize service system
-await initializeServiceSystem();
-// Test service discovery
-const joke = serviceManager.registry.get('tell-joke');
-assert(joke !== undefined, 'Should find tell-joke service');
-assertEquals(joke.name, 'Random Joke', 'Service name should match');
-// Test validation with valid input
-const validationResult = serviceManager.validate('tell-joke', { topic: 'programming' });
-assert(validationResult.valid, 'Valid input should pass validation');
-// Tell-joke service has no required fields, so empty object is valid
-const emptyInputResult = serviceManager.validate('tell-joke', {});
-assert(emptyInputResult.valid, 'Empty input should be valid for tell-joke service');
-// Test with truly invalid input (wrong type)
-const invalidResult = serviceManager.validate('tell-joke', { topic: 123 });
-assert(!invalidResult.valid, 'Invalid input type should fail validation');
-console.log('✅ Manager: integration works correctly');
-// Test 5: Service Input Schema Validation
-console.log('Testing service input schema validation...');
-// Test api-proxy service validation
-const apiProxy = serviceManager.registry.get('api-proxy');
-assert(apiProxy !== undefined, 'Should find api-proxy service');
-const validApiInput = { url: 'https://api.example.com/test', method: 'GET' };
-const validApiResult = serviceManager.validate('api-proxy', validApiInput);
-assert(validApiResult.valid, 'Valid api-proxy input should pass');
-const invalidApiInput = { method: 'GET' }; // missing required url
-const invalidApiResult = serviceManager.validate('api-proxy', invalidApiInput);
-assert(!invalidApiResult.valid, 'Invalid api-proxy input should fail');
-console.log('✅ Validation: input schema validation works correctly');
-// Test 6: Service Categories
-console.log('Testing service categories...');
-// Check that services have appropriate categories
-const categorizedServices = serviceManager.registry.list();
-const categories = new Set(categorizedServices.map(s => s.category).filter(Boolean));
-assert(categories.size > 0, 'Should have services with categories');
-// Verify known categories
-const expectedCategories = ['utility', 'ai', 'entertainment', 'development'];
-for (const category of expectedCategories) {
-    const servicesInCategory = categorizedServices.filter(s => s.category === category);
-    assert(servicesInCategory.length > 0, `Should have services in ${category} category`);
-}
-console.log('✅ Categories: service categorization works correctly');
-// Test 7: Service Loading Error Handling
-console.log('Testing service loading error handling...');
-// Test loading from non-existent directory
-try {
-    await serviceLoader.loadFromDirectory('/non/existent/directory');
-    // Should not throw, but return empty array
-    console.log('✅ Loader: graceful handling of non-existent directory');
-}
-catch {
-    // This is also acceptable behavior
-    console.log('✅ Loader: appropriate error handling for non-existent directory');
-}
-// Test 8: Service Prompt Files
-console.log('Testing service prompt files...');
-// Check that services with prompt files can be found
-const servicesWithPrompts = categorizedServices.filter(s => s.promptFile);
-assert(servicesWithPrompts.length > 0, 'Should have services with prompt files');
-// Verify prompt files exist
-for (const service of servicesWithPrompts.slice(0, 3)) { // Test first 3 to avoid excessive file I/O
-    if (service.promptFile) {
-        const promptPath = path.resolve(projectRoot, service.promptFile);
-        assert(fs.existsSync(promptPath), `Prompt file should exist: ${service.promptFile}`);
-        const content = fs.readFileSync(promptPath, 'utf-8');
-        assert(content.includes(service.id), `Prompt should reference service ID: ${service.id}`);
-    }
-}
-console.log('✅ Prompts: service prompt files work correctly');
-// Test 9: Service Registry Search and Filter
-console.log('Testing service registry search and filter...');
-// Test filtering by category
-const aiServices = categorizedServices.filter(s => s.category === ServiceCategory.AI);
-assert(aiServices.length > 0, 'Should have AI services');
-const utilityServices = categorizedServices.filter(s => s.category === ServiceCategory.UTILITY);
-assert(utilityServices.length > 0, 'Should have utility services');
-// Test name search
-const jokeServices = categorizedServices.filter(s => s.name.toLowerCase().includes('joke'));
-assert(jokeServices.length > 0, 'Should find joke-related services');
-console.log('✅ Search: service filtering works correctly');
-// Test 10: Service System State Consistency
-console.log('Testing service system state consistency...');
-// Verify that registry and manager are in sync
-const registryServices = serviceManager.registry.list();
-const registryIds = new Set(registryServices.map(s => s.id));
-// All services should be unique
-assertEquals(registryIds.size, registryServices.length, 'All service IDs should be unique');
-// All services should have valid pricing
-for (const service of registryServices) {
-    assert(service.defaultPrice > 0, `Service ${service.id} should have valid price`);
-    assert(service.name.length > 0, `Service ${service.id} should have a name`);
-    assert(service.description.length > 0, `Service ${service.id} should have a description`);
-}
-console.log('✅ Consistency: service system state is consistent');
-console.log('\n========================================');
-console.log('Service System Tests completed: All tests passed!');
-console.log('========================================\n');

package/dist/src/test/taskflow.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * TaskFlow Integration Tests
- *
- * Verifies that the plugin correctly interacts with api.runtime.taskFlow
- * when receiving service requests or responses.
- */
-export {};

package/dist/src/test/taskflow.test.js

@@ -1,82 +0,0 @@
-/**
- * TaskFlow Integration Tests
- *
- * Verifies that the plugin correctly interacts with api.runtime.taskFlow
- * when receiving service requests or responses.
- */
-import { register } from '../../index.js';
-// Simple test runner
-let passed = 0;
-let failed = 0;
-async function test(name, fn) {
-    try {
-        await fn();
-        console.log(`  ✓ ${name}`);
-        passed++;
-    }
-    catch (err) {
-        console.log(`  ✗ ${name}`);
-        console.log(err);
-        failed++;
-    }
-}
-function assert(condition, message) {
-    if (!condition)
-        throw new Error(`Assertion failed: ${message}`);
-}
-async function run() {
-    console.log('TaskFlow Integration Tests\n');
-    let createdFlows = [];
-    let registeredService = null;
-    const mockApi = {
-        logger: {
-            info: () => { },
-            error: () => { },
-            warn: () => { },
-            debug: () => { }
-        },
-        runtime: {
-            taskFlow: {
-                create: (flow) => {
-                    createdFlows.push(flow);
-                    return { id: `flow_${createdFlows.length}` };
-                }
-            }
-        },
-        registerTool: () => { },
-        registerService: (service) => {
-            registeredService = service;
-        },
-        registerCommand: () => { },
-        registerCli: () => { },
-        getConfig: () => ({
-            plugins: {
-                entries: {
-                    'sv_overlay': {
-                        config: {
-                            network: 'testnet'
-                        }
-                    }
-                }
-            }
-        })
-    };
-    await test('Background service uses taskFlow on events', async () => {
-        // 1. Register the plugin
-        register(mockApi);
-        // 2. Verify service was registered
-        assert(registeredService !== null, 'service should be registered');
-        // Note: To truly test the WebSocket event handling, we would need to mock
-        // the 'spawn' and 'stdout' of the child process. Since that's complex
-        // for a simple test, we verify the presence of the logic in index.ts.
-        // We can check if createdFlows is empty initially
-        assert(createdFlows.length === 0, 'no flows should be created yet');
-    });
-    console.log(`\n${passed} passed, ${failed} failed`);
-    if (failed > 0)
-        process.exit(1);
-}
-run().catch(err => {
-    console.error(err);
-    process.exit(1);
-});

package/dist/src/test/utils/server-logic.d.ts

@@ -1,98 +0,0 @@
-/**
- * Server validation logic mirrored from openclaw-overlay.
- *
- * This module contains the exact same parsing and validation logic
- * used by the server's topic managers, allowing us to validate
- * client output before submission.
- *
- * Updated to use PushDrop tokens instead of plain OP_RETURN.
- */
-import { Script, LockingScript } from '@bsv/sdk';
-export declare const PROTOCOL_ID = "openclaw-overlay-v1";
-export interface OpenclawIdentityData {
-    protocol: string;
-    type: 'identity';
-    identityKey: string;
-    name: string;
-    description: string;
-    channels: Record<string, string>;
-    capabilities: string[];
-    timestamp: string;
-}
-export interface OpenclawIdentityRevocationData {
-    protocol: string;
-    type: 'identity-revocation';
-    identityKey: string;
-    reason?: string;
-    timestamp: string;
-}
-export interface OpenclawServiceData {
-    protocol: string;
-    type: 'service';
-    identityKey: string;
-    serviceId: string;
-    name: string;
-    description: string;
-    pricing: {
-        model: string;
-        amountSats: number;
-    };
-    timestamp: string;
-}
-export type OpenclawPayload = OpenclawIdentityData | OpenclawIdentityRevocationData | OpenclawServiceData;
-export interface AdmittanceResult {
-    outputsToAdmit: number[];
-    coinsToRetain: number[];
-}
-export interface STEAKResponse {
-    [topic: string]: AdmittanceResult;
-}
-/**
- * Extract data fields from a PushDrop script using the SDK's decode method.
- * Returns the fields array or null if not a valid PushDrop script.
- */
-export declare function extractPushDropFields(script: Script | LockingScript): number[][] | null;
-/**
- * Legacy function for backwards compatibility - extracts from OP_RETURN scripts.
- * @deprecated Use extractPushDropFields instead
- */
-export declare function extractOpReturnPushes(script: Script): Uint8Array[] | null;
-/**
- * Parse identity payload from a PushDrop script.
- * The first field contains the JSON payload.
- */
-export declare function parseIdentityOutput(script: Script | LockingScript): OpenclawIdentityData | null;
-/**
- * Parse identity revocation payload from a PushDrop script.
- */
-export declare function parseRevocationOutput(script: Script | LockingScript): OpenclawIdentityRevocationData | null;
-/**
- * Parse service payload from a PushDrop script.
- */
-export declare function parseServiceOutput(script: Script | LockingScript): OpenclawServiceData | null;
-/**
- * Simulate the identity topic manager's identifyAdmissibleOutputs.
- */
-export declare function identifyIdentityOutputs(beef: number[]): AdmittanceResult;
-/**
- * Simulate the services topic manager's identifyAdmissibleOutputs.
- */
-export declare function identifyServiceOutputs(beef: number[]): AdmittanceResult;
-/**
- * Validate BEEF format and structure.
- */
-export declare function validateBeef(beef: number[]): {
-    valid: boolean;
-    error?: string;
-    version?: number;
-    txCount?: number;
-    hasProofs?: boolean;
-};
-/**
- * Validate BEEF has proper ancestry chain.
- */
-export declare function validateBeefAncestry(beef: number[]): {
-    valid: boolean;
-    error?: string;
-    chain?: string[];
-};