openclaw-overlay-plugin 0.8.18 → 0.8.19

package/src/test/request-response-flow.test.ts

@@ -1,253 +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: string, fn: () => void | Promise<void>) {
-  return (async () => {
-    try {
-      await fn();
-      console.log(`  ✓ ${name}`);
-      passed++;
-    } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.log(`  ✗ ${name}`);
-      console.log(`    ${msg}`);
-      failed++;
-    }
-  })();
-}
-
-function assert(condition: boolean, message: string) {
-  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 as Record<string, unknown>).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: string[] = [];
-      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: string) => JSON.parse(line));
-
-    assert(remaining.length === 2, `Expected 2 remaining entries, got ${remaining.length}`);
-    assert(remaining.find((e: any) => e.requestId === 'pending-1') !== undefined, 'Should keep recent pending');
-    assert(remaining.find((e: any) => e.requestId === 'recent-fulfilled') !== undefined, 'Should keep recent fulfilled');
-    assert(remaining.find((e: any) => e.requestId === 'old-fulfilled') === undefined, 'Should remove old fulfilled');
-    assert(remaining.find((e: any) => 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: string, newStatus: string, 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: string) => {
-        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: string, _newStatus: string) {
-      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: string) => {
-        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/src/test/service-system.test.ts

@@ -1,241 +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 { ServiceDefinition, ServiceCategory } from '../services/types.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const projectRoot = path.resolve(__dirname, '..', '..');
-
-// Test helper functions
-function assert(condition: boolean, message: string) {
-  if (!condition) {
-    throw new Error(`Assertion failed: ${message}`);
-  }
-}
-
-function assertEquals(actual: any, expected: any, message?: string) {
-  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: ServiceDefinition = {
-  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: any) {
-  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
-  } as ServiceDefinition);
-  throw new Error('Should have thrown error for invalid service');
-} catch (error: any) {
-  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/src/test/taskflow.test.ts

@@ -1,95 +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';
-import path from 'node:path';
-import os from 'node:os';
-import fs from 'node:fs';
-
-// Simple test runner
-let passed = 0;
-let failed = 0;
-
-async function test(name: string, fn: () => void | Promise<void>) {
-  try {
-    await fn();
-    console.log(`  ✓ ${name}`);
-    passed++;
-  } catch (err: unknown) {
-    console.log(`  ✗ ${name}`);
-    console.log(err);
-    failed++;
-  }
-}
-
-function assert(condition: boolean, message: string) {
-  if (!condition) throw new Error(`Assertion failed: ${message}`);
-}
-
-async function run() {
-  console.log('TaskFlow Integration Tests\n');
-
-  let createdFlows: any[] = [];
-  let registeredService: any = null;
-
-  const mockApi = {
-    logger: {
-      info: () => {},
-      error: () => {},
-      warn: () => {},
-      debug: () => {}
-    },
-    runtime: {
-      taskFlow: {
-        create: (flow: any) => {
-          createdFlows.push(flow);
-          return { id: `flow_${createdFlows.length}` };
-        }
-      }
-    },
-    registerTool: () => {},
-    registerService: (service: any) => {
-      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);
-});