openclaw-overlay-plugin 0.7.22

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

@@ -0,0 +1,190 @@
+/**
+ * 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/test/utils/server-logic.d.ts

@@ -0,0 +1,98 @@
+/**
+ * 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[];
+};

package/dist/test/utils/server-logic.js

@@ -0,0 +1,286 @@
+/**
+ * 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 { OP, Beef, PushDrop } from '@bsv/sdk';
+export const PROTOCOL_ID = 'openclaw-overlay-v1';
+// ============================================================================
+// Script Parsing using PushDrop.decode()
+// ============================================================================
+/**
+ * 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 function extractPushDropFields(script) {
+    try {
+        const decoded = PushDrop.decode(script);
+        return decoded.fields;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Legacy function for backwards compatibility - extracts from OP_RETURN scripts.
+ * @deprecated Use extractPushDropFields instead
+ */
+export function extractOpReturnPushes(script) {
+    const chunks = script.chunks;
+    // Legacy 4+ chunk format: OP_FALSE OP_RETURN <data> <data> ...
+    if (chunks.length >= 4 &&
+        chunks[0].op === OP.OP_FALSE &&
+        chunks[1].op === OP.OP_RETURN) {
+        const pushes = [];
+        for (let i = 2; i < chunks.length; i++) {
+            if (chunks[i].data) {
+                pushes.push(new Uint8Array(chunks[i].data));
+            }
+        }
+        return pushes;
+    }
+    // Collapsed 2-chunk format: OP_FALSE OP_RETURN with data blob
+    if (chunks.length === 2 &&
+        chunks[0].op === OP.OP_FALSE &&
+        chunks[1].op === OP.OP_RETURN &&
+        chunks[1].data) {
+        const blob = chunks[1].data;
+        const pushes = [];
+        let pos = 0;
+        while (pos < blob.length) {
+            const op = blob[pos++];
+            if (op > 0 && op <= 75) {
+                const end = Math.min(pos + op, blob.length);
+                pushes.push(new Uint8Array(blob.slice(pos, end)));
+                pos = end;
+            }
+            else if (op === 0x4c) {
+                const len = blob[pos++] ?? 0;
+                const end = Math.min(pos + len, blob.length);
+                pushes.push(new Uint8Array(blob.slice(pos, end)));
+                pos = end;
+            }
+            else if (op === 0x4d) {
+                const len = (blob[pos] ?? 0) | ((blob[pos + 1] ?? 0) << 8);
+                pos += 2;
+                const end = Math.min(pos + len, blob.length);
+                pushes.push(new Uint8Array(blob.slice(pos, end)));
+                pos = end;
+            }
+            else if (op === 0x4e) {
+                const len = ((blob[pos] ?? 0) |
+                    ((blob[pos + 1] ?? 0) << 8) |
+                    ((blob[pos + 2] ?? 0) << 16) |
+                    ((blob[pos + 3] ?? 0) << 24)) >>> 0;
+                pos += 4;
+                const end = Math.min(pos + len, blob.length);
+                pushes.push(new Uint8Array(blob.slice(pos, end)));
+                pos = end;
+            }
+            else {
+                break;
+            }
+        }
+        return pushes.length >= 2 ? pushes : null;
+    }
+    return null;
+}
+// ============================================================================
+// Payload Parsing - Updated for PushDrop
+// ============================================================================
+/**
+ * Parse identity payload from a PushDrop script.
+ * The first field contains the JSON payload.
+ */
+export function parseIdentityOutput(script) {
+    const fields = extractPushDropFields(script);
+    if (!fields || fields.length < 1)
+        return null;
+    try {
+        const payload = JSON.parse(new TextDecoder().decode(new Uint8Array(fields[0])));
+        // Server validation rules
+        if (payload.protocol !== PROTOCOL_ID)
+            return null;
+        if (payload.type !== 'identity')
+            return null;
+        if (typeof payload.identityKey !== 'string' || !/^[0-9a-fA-F]{66}$/.test(payload.identityKey))
+            return null;
+        if (typeof payload.name !== 'string' || payload.name.length === 0)
+            return null;
+        if (!Array.isArray(payload.capabilities))
+            return null;
+        if (typeof payload.timestamp !== 'string')
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse identity revocation payload from a PushDrop script.
+ */
+export function parseRevocationOutput(script) {
+    const fields = extractPushDropFields(script);
+    if (!fields || fields.length < 1)
+        return null;
+    try {
+        const payload = JSON.parse(new TextDecoder().decode(new Uint8Array(fields[0])));
+        if (payload.protocol !== PROTOCOL_ID)
+            return null;
+        if (payload.type !== 'identity-revocation')
+            return null;
+        if (typeof payload.identityKey !== 'string' || !/^[0-9a-fA-F]{66}$/.test(payload.identityKey))
+            return null;
+        if (typeof payload.timestamp !== 'string')
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse service payload from a PushDrop script.
+ */
+export function parseServiceOutput(script) {
+    const fields = extractPushDropFields(script);
+    if (!fields || fields.length < 1)
+        return null;
+    try {
+        const payload = JSON.parse(new TextDecoder().decode(new Uint8Array(fields[0])));
+        if (payload.protocol !== PROTOCOL_ID)
+            return null;
+        if (payload.type !== 'service')
+            return null;
+        if (typeof payload.identityKey !== 'string' || !/^[0-9a-fA-F]{66}$/.test(payload.identityKey))
+            return null;
+        if (typeof payload.serviceId !== 'string' || payload.serviceId.length === 0)
+            return null;
+        if (typeof payload.name !== 'string' || payload.name.length === 0)
+            return null;
+        if (!payload.pricing || typeof payload.pricing.amountSats !== 'number')
+            return null;
+        if (typeof payload.timestamp !== 'string')
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================================
+// Topic Manager Simulation
+// ============================================================================
+/**
+ * Simulate the identity topic manager's identifyAdmissibleOutputs.
+ */
+export function identifyIdentityOutputs(beef) {
+    const parsedBeef = Beef.fromBinary(beef);
+    const subjectTx = parsedBeef.txs[0]?._tx;
+    if (!subjectTx) {
+        return { outputsToAdmit: [], coinsToRetain: [] };
+    }
+    const outputsToAdmit = [];
+    for (let i = 0; i < subjectTx.outputs.length; i++) {
+        const output = subjectTx.outputs[i];
+        if (output.lockingScript) {
+            // Check identity
+            const identity = parseIdentityOutput(output.lockingScript);
+            if (identity !== null) {
+                outputsToAdmit.push(i);
+                continue;
+            }
+            // Check revocation
+            const revocation = parseRevocationOutput(output.lockingScript);
+            if (revocation !== null) {
+                outputsToAdmit.push(i);
+            }
+        }
+    }
+    return { outputsToAdmit, coinsToRetain: [] };
+}
+/**
+ * Simulate the services topic manager's identifyAdmissibleOutputs.
+ */
+export function identifyServiceOutputs(beef) {
+    const parsedBeef = Beef.fromBinary(beef);
+    const subjectTx = parsedBeef.txs[0]?._tx;
+    if (!subjectTx) {
+        return { outputsToAdmit: [], coinsToRetain: [] };
+    }
+    const outputsToAdmit = [];
+    for (let i = 0; i < subjectTx.outputs.length; i++) {
+        const output = subjectTx.outputs[i];
+        if (output.lockingScript) {
+            const service = parseServiceOutput(output.lockingScript);
+            if (service !== null) {
+                outputsToAdmit.push(i);
+            }
+        }
+    }
+    return { outputsToAdmit, coinsToRetain: [] };
+}
+// ============================================================================
+// BEEF Validation
+// ============================================================================
+/**
+ * Validate BEEF format and structure.
+ */
+export function validateBeef(beef) {
+    try {
+        // Check magic bytes
+        if (beef.length < 4) {
+            return { valid: false, error: 'BEEF too short' };
+        }
+        const magic = beef.slice(0, 4);
+        const magicHex = magic.map(b => b.toString(16).padStart(2, '0')).join('');
+        if (magicHex !== '0100beef' && magicHex !== '0200beef') {
+            return { valid: false, error: `Invalid magic bytes: ${magicHex}` };
+        }
+        const version = magicHex === '0100beef' ? 1 : 2;
+        // Parse BEEF
+        const parsed = Beef.fromBinary(beef);
+        if (!parsed.txs || parsed.txs.length === 0) {
+            return { valid: false, error: 'BEEF contains no transactions' };
+        }
+        // Check for merkle proofs
+        const hasProofs = parsed.bumps && parsed.bumps.length > 0;
+        return {
+            valid: true,
+            version,
+            txCount: parsed.txs.length,
+            hasProofs,
+        };
+    }
+    catch (e) {
+        return { valid: false, error: e instanceof Error ? e.message : 'Unknown error' };
+    }
+}
+/**
+ * Validate BEEF has proper ancestry chain.
+ */
+export function validateBeefAncestry(beef) {
+    try {
+        const parsed = Beef.fromBinary(beef);
+        const chain = [];
+        for (const btx of parsed.txs) {
+            const txid = btx.txid || btx._tx?.id('hex');
+            if (txid)
+                chain.push(txid);
+        }
+        // Use Beef's built-in validation
+        const isValid = parsed.isValid(false);
+        if (!isValid) {
+            return { valid: false, error: 'BEEF ancestry chain is invalid', chain };
+        }
+        return { valid: true, chain };
+    }
+    catch (e) {
+        return { valid: false, error: e instanceof Error ? e.message : 'Unknown error' };
+    }
+}

package/dist/test/wallet.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @a2a-bsv/core — Wallet tests
+ *
+ * These tests verify that BSVAgentWallet can be instantiated and its basic
+ * methods are callable. Full integration tests require a funded testnet wallet.
+ */
+export {};