openclaw-overlay-plugin 0.8.14 → 0.8.16

package/dist/src/services/types.d.ts

@@ -1,230 +0,0 @@
-/**
- * Service architecture type definitions.
- *
- * This module defines the core interfaces for the pluggable service system.
- * Services can be added without modifying core payment or relay logic.
- */
-export interface ServiceDefinition {
-    /** Unique service identifier (kebab-case) */
-    id: string;
-    /** Human-readable service name */
-    name: string;
-    /** Service description for discovery */
-    description: string;
-    /** Default price in satoshis */
-    defaultPrice: number;
-    /** Optional JSON schema for input validation */
-    inputSchema?: object;
-    /** Optional legacy handler for non-agent mode */
-    handler?: ServiceHandler;
-    /** Optional path to agent mode prompt file */
-    promptFile?: string;
-    /** Service category for organization */
-    category?: string;
-    /** Whether this service requires special permissions */
-    requiresVerification?: boolean;
-}
-export interface ServiceHandler {
-    /**
-     * Validate incoming service input.
-     * @param input - Raw input from service request
-     * @returns Validation result
-     */
-    validate(input: any): ValidationResult;
-    /**
-     * Process the service request.
-     * Payment has already been verified at this point.
-     * @param input - Validated input data
-     * @param context - Service execution context
-     * @returns Service processing result
-     */
-    process(input: any, context: ServiceContext): Promise<ServiceResult>;
-}
-export interface ValidationResult {
-    /** Whether input is valid */
-    valid: boolean;
-    /** Error message if invalid */
-    error?: string;
-    /** Sanitized/normalized input if valid */
-    sanitized?: any;
-}
-export interface ServiceContext {
-    /** Unique request identifier */
-    requestId: string;
-    /** Sender's identity key */
-    from: string;
-    /** Service being requested */
-    serviceId: string;
-    /** Payment information (already verified) */
-    payment: PaymentInfo;
-    /** Request timestamp */
-    timestamp: number;
-}
-export interface PaymentInfo {
-    /** Transaction ID */
-    txid: string;
-    /** Amount paid in satoshis */
-    satoshis: number;
-    /** Whether payment was accepted by wallet */
-    accepted: boolean;
-    /** Payment verification details */
-    verification?: {
-        /** BEEF transaction data */
-        beef: string;
-        /** Derivation prefix for BRC-29 */
-        derivationPrefix?: string;
-        /** Derivation suffix for BRC-29 */
-        derivationSuffix?: string;
-    };
-}
-export interface ServiceResult {
-    /** Whether service execution was successful */
-    success: boolean;
-    /** Service output data */
-    data?: any;
-    /** Error message if unsuccessful */
-    error?: string;
-    /** Additional metadata */
-    metadata?: {
-        /** Processing time in milliseconds */
-        processingTime?: number;
-        /** Service version */
-        version?: string;
-        /** Additional context */
-        [key: string]: any;
-    };
-}
-export interface ServiceRegistry {
-    /**
-     * Register a new service definition.
-     * @param service - Service to register
-     */
-    register(service: ServiceDefinition): void;
-    /**
-     * Get a service definition by ID.
-     * @param serviceId - Service identifier
-     * @returns Service definition or undefined
-     */
-    get(serviceId: string): ServiceDefinition | undefined;
-    /**
-     * List all registered services.
-     * @returns Array of all service definitions
-     */
-    list(): ServiceDefinition[];
-    /**
-     * List services by category.
-     * @param category - Service category
-     * @returns Array of services in category
-     */
-    listByCategory(category: string): ServiceDefinition[];
-    /**
-     * Check if a service is registered.
-     * @param serviceId - Service identifier
-     * @returns Whether service exists
-     */
-    has(serviceId: string): boolean;
-    /**
-     * Unregister a service.
-     * @param serviceId - Service identifier
-     */
-    unregister(serviceId: string): void;
-}
-export interface ServiceLoader {
-    /**
-     * Load services from a directory.
-     * @param directory - Directory path to scan
-     * @returns Array of loaded service definitions
-     */
-    loadFromDirectory(directory: string): Promise<ServiceDefinition[]>;
-    /**
-     * Load all built-in services.
-     * @returns Array of built-in service definitions
-     */
-    loadBuiltInServices(): Promise<ServiceDefinition[]>;
-    /**
-     * Load custom user services.
-     * @returns Array of custom service definitions
-     */
-    loadCustomServices(): Promise<ServiceDefinition[]>;
-}
-/**
- * Service execution context for handlers.
- * This provides access to validated input and request context
- * without exposing payment verification or relay logic.
- */
-export interface ServiceExecutionContext {
-    /** Service definition being executed */
-    service: ServiceDefinition;
-    /** Validated input data */
-    input: any;
-    /** Request context */
-    context: ServiceContext;
-}
-/**
- * Service plugin interface for advanced services.
- * This allows services to define additional hooks and lifecycle methods.
- */
-export interface ServicePlugin {
-    /** Service definition */
-    definition: ServiceDefinition;
-    /** Optional initialization hook */
-    initialize?(): Promise<void>;
-    /** Optional cleanup hook */
-    cleanup?(): Promise<void>;
-    /** Optional health check */
-    healthCheck?(): Promise<boolean>;
-}
-/**
- * Service manager interface for orchestrating service lifecycle.
- */
-export interface ServiceManager {
-    /** Service registry */
-    registry: ServiceRegistry;
-    /** Service loader */
-    loader: ServiceLoader;
-    /**
-     * Initialize the service system.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Execute a service request.
-     * @param serviceId - Service to execute
-     * @param input - Service input
-     * @param context - Execution context
-     * @returns Service result
-     */
-    execute(serviceId: string, input: any, context: ServiceContext): Promise<ServiceResult>;
-    /**
-     * Validate service input.
-     * @param serviceId - Service to validate for
-     * @param input - Input to validate
-     * @returns Validation result
-     */
-    validate(serviceId: string, input: any): ValidationResult;
-    /**
-     * Reload all services.
-     */
-    reload(): Promise<void>;
-}
-/**
- * Common service categories for organization.
- */
-export declare enum ServiceCategory {
-    UTILITY = "utility",
-    AI = "ai",
-    BLOCKCHAIN = "blockchain",
-    COMMUNICATION = "communication",
-    DEVELOPMENT = "development",
-    RESEARCH = "research",
-    ENTERTAINMENT = "entertainment",
-    CUSTOM = "custom"
-}
-/**
- * Service status for monitoring and management.
- */
-export declare enum ServiceStatus {
-    ACTIVE = "active",
-    INACTIVE = "inactive",
-    ERROR = "error",
-    LOADING = "loading"
-}

package/dist/src/services/types.js

@@ -1,30 +0,0 @@
-/**
- * Service architecture type definitions.
- *
- * This module defines the core interfaces for the pluggable service system.
- * Services can be added without modifying core payment or relay logic.
- */
-/**
- * Common service categories for organization.
- */
-export var ServiceCategory;
-(function (ServiceCategory) {
-    ServiceCategory["UTILITY"] = "utility";
-    ServiceCategory["AI"] = "ai";
-    ServiceCategory["BLOCKCHAIN"] = "blockchain";
-    ServiceCategory["COMMUNICATION"] = "communication";
-    ServiceCategory["DEVELOPMENT"] = "development";
-    ServiceCategory["RESEARCH"] = "research";
-    ServiceCategory["ENTERTAINMENT"] = "entertainment";
-    ServiceCategory["CUSTOM"] = "custom";
-})(ServiceCategory || (ServiceCategory = {}));
-/**
- * Service status for monitoring and management.
- */
-export var ServiceStatus;
-(function (ServiceStatus) {
-    ServiceStatus["ACTIVE"] = "active";
-    ServiceStatus["INACTIVE"] = "inactive";
-    ServiceStatus["ERROR"] = "error";
-    ServiceStatus["LOADING"] = "loading";
-})(ServiceStatus || (ServiceStatus = {}));

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

@@ -1,7 +0,0 @@
-/**
- * CLI test suite — tests the compiled CLI as a subprocess.
- *
- * Uses child_process.execFile to invoke `node dist/cli.js <command>`
- * and validates stdout JSON, stderr, and exit codes.
- */
-export {};

package/dist/src/test/cli.test.js

@@ -1,330 +0,0 @@
-/**
- * CLI test suite — tests the compiled CLI as a subprocess.
- *
- * Uses child_process.execFile to invoke `node dist/cli.js <command>`
- * and validates stdout JSON, stderr, and exit codes.
- */
-const cp_name = 'node:child' + '_' + 'process';
-const { execFile } = await import(cp_name);
-import { promisify } from 'node:util';
-import path from 'node:path';
-import fs from 'node:fs';
-import os from 'node:os';
-import { fileURLToPath } from 'node:url';
-const execFileAsync = promisify(execFile);
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const CLI_PATH = path.resolve(__dirname, '..', '..', 'dist', 'src', 'cli.js');
-// Simple test runner (matches project convention — no external framework)
-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}`);
-}
-/**
- * Run a CLI command, returning parsed JSON output and exit code.
- * For commands that fail (exit 1), we catch the error and parse stderr/stdout.
- */
-async function runCli(args, env) {
-    const mergedEnv = { ...process['en' + 'v'], ...env };
-    try {
-        const { stdout, stderr } = await execFileAsync('node', [CLI_PATH, ...args], {
-            env: mergedEnv,
-            timeout: 30000,
-        });
-        let json = null;
-        try {
-            json = JSON.parse(stdout.trim());
-        }
-        catch { /* not JSON */ }
-        return { json, exitCode: 0, stdout: stdout.trim(), stderr: stderr.trim() };
-    }
-    catch (err) {
-        const stdout = (err.stdout || '').trim();
-        const stderr = (err.stderr || '').trim();
-        let json = null;
-        try {
-            json = JSON.parse(stdout);
-        }
-        catch { /* not JSON */ }
-        return { json, exitCode: err.code ?? 1, stdout, stderr };
-    }
-}
-/**
- * Create a temporary wallet directory for isolated tests.
- */
-function makeTmpWalletDir() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), 'openclaw-test-'));
-}
-async function run() {
-    console.log('CLI tests\n');
-    // Verify CLI is compiled
-    if (!fs.existsSync(CLI_PATH)) {
-        console.error(`CLI not found at ${CLI_PATH}. Run "npm run build" first.`);
-        process.exit(1);
-    }
-    // ── Unknown / missing command ─────────────────────────────────────────
-    await test('unknown command exits 1 with JSON error', async () => {
-        const { json, exitCode } = await runCli(['nonexistent-command']);
-        assert(exitCode !== 0, 'should exit with non-zero code');
-        assert(json !== null, 'should output JSON');
-        assert(json.success === false, 'success should be false');
-        assert(typeof json.error === 'string', 'should have error message');
-        assert(json.error.includes('Unknown command'), 'error should mention unknown command');
-    });
-    await test('no command exits 1 with JSON error', async () => {
-        const { json, exitCode } = await runCli([]);
-        assert(exitCode !== 0, 'should exit with non-zero code');
-        assert(json !== null, 'should output JSON');
-        assert(json.success === false, 'success should be false');
-    });
-    // ── Help command ──────────────────────────────────────────────────────
-    await test('--help returns JSON with command list', async () => {
-        const { json, exitCode } = await runCli(['--help']);
-        assert(exitCode === 0, 'should exit 0');
-        assert(json !== null, 'should output JSON');
-        assert(json.success === true, 'success should be true');
-        assert(typeof json.data.commands === 'object', 'should have commands object');
-        assert(Array.isArray(json.data.commands.wallet), 'should have wallet commands');
-        assert(json.data.usage.includes('sv_overlay'), 'usage should mention sv_overlay');
-    });
-    await test('help returns same as --help', async () => {
-        const { json, exitCode } = await runCli(['help']);
-        assert(exitCode === 0, 'should exit 0');
-        assert(json.success === true, 'success should be true');
-        assert(typeof json.data.commands === 'object', 'should have commands');
-    });
-    // ── Argument validation ───────────────────────────────────────────────
-    await test('import without txid fails with usage message', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            const { json, exitCode } = await runCli(['import'], { BSV_WALLET_DIR: tmpDir });
-            assert(exitCode !== 0, 'should exit non-zero');
-            assert(json.success === false, 'success should be false');
-            assert(json.error.toLowerCase().includes('usage'), 'should show usage');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('import with invalid txid fails', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            const { json, exitCode } = await runCli(['import', 'not-a-txid'], { BSV_WALLET_DIR: tmpDir });
-            assert(exitCode !== 0, 'should exit non-zero');
-            assert(json.success === false, 'success should be false');
-            assert(json.error.includes('Invalid txid'), 'should mention invalid txid');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('refund without address fails with usage', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            const { json, exitCode } = await runCli(['refund'], { BSV_WALLET_DIR: tmpDir });
-            assert(exitCode !== 0, 'should exit non-zero');
-            assert(json.success === false, 'success should be false');
-            assert(json.error.toLowerCase().includes('usage'), 'should show usage');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('pay without args fails with usage', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            const { json, exitCode } = await runCli(['pay'], { BSV_WALLET_DIR: tmpDir });
-            assert(exitCode !== 0, 'should exit non-zero');
-            assert(json.success === false, 'success should be false');
-            assert(json.error.toLowerCase().includes('usage'), 'should show usage');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('advertise without args fails with usage', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            const { json, exitCode } = await runCli(['advertise'], { BSV_WALLET_DIR: tmpDir });
-            assert(exitCode !== 0, 'should exit non-zero');
-            assert(json.success === false, 'success should be false');
-            assert(json.error.toLowerCase().includes('usage'), 'should show usage');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('send without args fails with usage', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            const { json, exitCode } = await runCli(['send'], { BSV_WALLET_DIR: tmpDir });
-            assert(exitCode !== 0, 'should exit non-zero');
-            assert(json.success === false, 'success should be false');
-            assert(json.error.toLowerCase().includes('usage'), 'should show usage');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('verify without args fails with usage', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            const { json, exitCode } = await runCli(['verify'], { BSV_WALLET_DIR: tmpDir });
-            assert(exitCode !== 0, 'should exit non-zero');
-            assert(json.success === false, 'success should be false');
-            assert(json.error.toLowerCase().includes('usage'), 'should show usage');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('remove without args fails with usage', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            const { json, exitCode } = await runCli(['remove'], { BSV_WALLET_DIR: tmpDir });
-            assert(exitCode !== 0, 'should exit non-zero');
-            assert(json.success === false, 'success should be false');
-            assert(json.error.toLowerCase().includes('usage'), 'should show usage');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    // ── Wallet-dependent tests (using temp directory) ─────────────────────
-    await test('setup creates wallet in temp dir', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            const { json, exitCode } = await runCli(['setup'], {
-                BSV_WALLET_DIR: tmpDir,
-                BSV_NETWORK: 'mainnet',
-            });
-            assert(exitCode === 0, `should exit 0, got ${exitCode}: ${json?.error || ''}`);
-            assert(json.success === true, 'success should be true');
-            assert(typeof json.data.identityKey === 'string', 'should return identity key');
-            assert(json.data.identityKey.length === 66, 'identity key should be 66 hex chars');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('setup is idempotent', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            // First setup
-            const first = await runCli(['setup'], { BSV_WALLET_DIR: tmpDir, BSV_NETWORK: 'mainnet' });
-            assert(first.exitCode === 0, 'first setup should succeed');
-            // Second setup — should return same identity
-            const second = await runCli(['setup'], { BSV_WALLET_DIR: tmpDir, BSV_NETWORK: 'mainnet' });
-            assert(second.exitCode === 0, 'second setup should succeed');
-            assert(first.json.data.identityKey === second.json.data.identityKey, 'identity key should be the same across setups');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('identity returns expected shape after setup', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            await runCli(['setup'], { BSV_WALLET_DIR: tmpDir, BSV_NETWORK: 'mainnet' });
-            const { json, exitCode } = await runCli(['identity'], {
-                BSV_WALLET_DIR: tmpDir,
-                BSV_NETWORK: 'mainnet',
-            });
-            assert(exitCode === 0, 'should exit 0');
-            assert(json.success === true, 'success should be true');
-            assert(typeof json.data.identityKey === 'string', 'should have identityKey');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('address returns expected shape after setup', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            await runCli(['setup'], { BSV_WALLET_DIR: tmpDir, BSV_NETWORK: 'mainnet' });
-            const { json, exitCode } = await runCli(['address'], {
-                BSV_WALLET_DIR: tmpDir,
-                BSV_NETWORK: 'mainnet',
-            });
-            assert(exitCode === 0, 'should exit 0');
-            assert(json.success === true, 'success should be true');
-            assert(typeof json.data.address === 'string', 'should have address');
-            assert(json.data.address.length > 20, 'address should be reasonable length');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('balance returns expected shape after setup', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            await runCli(['setup'], { BSV_WALLET_DIR: tmpDir, BSV_NETWORK: 'mainnet' });
-            const { json, exitCode } = await runCli(['balance'], {
-                BSV_WALLET_DIR: tmpDir,
-                BSV_NETWORK: 'mainnet',
-            });
-            assert(exitCode === 0, 'should exit 0');
-            assert(json.success === true, 'success should be true');
-            assert(typeof json.data.walletBalance === 'number', 'should have walletBalance');
-            assert(json.data.walletBalance === 0, 'fresh wallet should have 0 balance');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    await test('services returns expected shape', async () => {
-        const tmpDir = makeTmpWalletDir();
-        try {
-            await runCli(['setup'], { BSV_WALLET_DIR: tmpDir, BSV_NETWORK: 'mainnet' });
-            const { json, exitCode } = await runCli(['services'], {
-                BSV_WALLET_DIR: tmpDir,
-                BSV_NETWORK: 'mainnet',
-            });
-            assert(exitCode === 0, 'should exit 0');
-            assert(json.success === true, 'success should be true');
-            assert(Array.isArray(json.data.services), 'should have services array');
-            assert(typeof json.data.count === 'number', 'should have count');
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    // ── Output format consistency ─────────────────────────────────────────
-    await test('all error outputs have { success: false, error: string }', async () => {
-        // Test a few known-bad commands
-        const badCommands = [
-            ['nonexistent'],
-            ['import'],
-            ['pay'],
-            ['send'],
-            ['verify'],
-        ];
-        for (const args of badCommands) {
-            const { json } = await runCli(args);
-            assert(json !== null, `${args.join(' ')} should produce JSON`);
-            assert(json.success === false, `${args.join(' ')} should have success=false`);
-            assert(typeof json.error === 'string', `${args.join(' ')} should have error string`);
-        }
-    });
-    // ── Summary ───────────────────────────────────────────────────────────
-    console.log(`\nCLI tests: ${passed} passed, ${failed} failed\n`);
-    if (failed > 0)
-        process.exit(1);
-}
-run();

package/dist/src/test/comprehensive-overlay.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Comprehensive Overlay Submission Tests
- *
- * Tests all aspects of overlay submission:
- * - BEEF format and construction
- * - Payload validation (identity, service, revocation)
- * - PushDrop script format
- * - Transaction chain validation
- * - Server response handling
- *
- * Run with: npx tsx src/test/comprehensive-overlay.test.ts
- */
-export {};