openclaw-cascade-plugin 1.0.12 → 1.0.14

package/src/test-utils/helpers.ts

@@ -1,107 +0,0 @@
-/**
- * Test helper utilities
- */
-
-import { join } from 'path';
-import { mkdir, rm } from 'fs/promises';
-
-export interface TestConfig {
-  cascadeGrpcEndpoint: string;
-  cascadePythonPath?: string;
-  firestoreProjectId?: string;
-  firestoreCredentialsPath?: string;
-  headless?: boolean;
-  actionTimeoutMs?: number;
-  enableA2A?: boolean;
-  verbose?: boolean;
-}
-
-export function createMockConfig(overrides: Partial<TestConfig> = {}): TestConfig {
-  return {
-    cascadeGrpcEndpoint: 'localhost:50051',
-    headless: false,
-    actionTimeoutMs: 8000,
-    enableA2A: true,
-    verbose: false,
-    ...overrides
-  };
-}
-
-export async function withTempDir(fn: (dir: string) => Promise<void>): Promise<void> {
-  const tmpDir = join(process.cwd(), '.test-tmp', Date.now().toString());
-  await mkdir(tmpDir, { recursive: true });
-  
-  try {
-    await fn(tmpDir);
-  } finally {
-    await rm(tmpDir, { recursive: true, force: true });
-  }
-}
-
-export function waitForCondition(
-  condition: () => boolean,
-  timeout = 5000,
-  interval = 100
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const start = Date.now();
-    const check = () => {
-      if (condition()) {
-        resolve();
-      } else if (Date.now() - start > timeout) {
-        reject(new Error(`Timeout waiting for condition after ${timeout}ms`));
-      } else {
-        setTimeout(check, interval);
-      }
-    };
-    check();
-  });
-}
-
-export function generateBase64Image(size: number): string {
-  // Generate fake base64 image data
-  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-  let result = '';
-  for (let i = 0; i < size; i++) {
-    result += chars[Math.floor(Math.random() * chars.length)];
-  }
-  // Pad to multiple of 4 for valid base64
-  while (result.length % 4 !== 0) {
-    result += '=';
-  }
-  return result;
-}
-
-export function createMockSpawnImplementation(
-  stdoutData: string | string[],
-  exitCode = 0
-): () => any {
-  return () => {
-    const { EventEmitter } = require('events');
-    const stdout = new EventEmitter();
-    const stderr = new EventEmitter();
-    
-    const proc = Object.assign(new EventEmitter(), {
-      stdout,
-      stderr,
-      stdin: { write: jest.fn() },
-      kill: jest.fn()
-    });
-
-    // Emit stdout data after a brief delay
-    setTimeout(() => {
-      const lines = Array.isArray(stdoutData) ? stdoutData : [stdoutData];
-      lines.forEach(line => stdout.emit('data', line + '\n'));
-      
-      setTimeout(() => {
-        proc.emit('close', exitCode);
-      }, 10);
-    }, 10);
-
-    return proc;
-  };
-}
-
-export function delay(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}

package/src/test-utils/index.ts

@@ -1,2 +0,0 @@
-export * from './mocks';
-export * from './helpers';

package/src/test-utils/mocks.ts

@@ -1,101 +0,0 @@
-/**
- * Mock implementations for testing
- */
-
-import { EventEmitter } from 'events';
-
-export interface MockChildProcess {
-  stdout: EventEmitter;
-  stderr: EventEmitter;
-  stdin: {
-    write: jest.Mock;
-  };
-  on: jest.Mock;
-  once: jest.Mock;
-  emit: jest.Mock;
-  kill: jest.Mock;
-  pid: number;
-  connected: boolean;
-  disconnect: jest.Mock;
-  unref: jest.Mock;
-  ref: jest.Mock;
-  send: jest.Mock;
-}
-
-export function createMockChildProcess(): MockChildProcess {
-  const stdout = new EventEmitter();
-  const stderr = new EventEmitter();
-  
-  return {
-    stdout,
-    stderr,
-    stdin: {
-      write: jest.fn()
-    },
-    on: jest.fn(),
-    once: jest.fn(),
-    emit: jest.fn(),
-    kill: jest.fn(),
-    pid: 12345,
-    connected: true,
-    disconnect: jest.fn(),
-    unref: jest.fn(),
-    ref: jest.fn(),
-    send: jest.fn()
-  };
-}
-
-export class MockCascadeMcpClient {
-  private tools = new Map<string, Function>();
-  public callTool = jest.fn();
-  public listTools = jest.fn();
-  public isConnected = jest.fn().mockReturnValue(true);
-  
-  registerMockTool(name: string, handler: Function) {
-    this.tools.set(name, handler);
-    this.callTool.mockImplementation(async (toolName: string, args: any) => {
-      if (toolName === name) {
-        return handler(args);
-      }
-      throw new Error(`Unknown tool: ${toolName}`);
-    });
-  }
-
-  simulateError(error: Error) {
-    this.callTool.mockRejectedValue(error);
-  }
-
-  simulateConnectionError() {
-    this.isConnected.mockReturnValue(false);
-  }
-}
-
-export class MockFirestore {
-  private data = new Map<string, any>();
-
-  setDocument(path: string, data: any) {
-    this.data.set(path, data);
-  }
-
-  collection(path: string) {
-    return {
-      get: async () => ({
-        docs: Array.from(this.data.entries())
-          .filter(([key]) => key.startsWith(path))
-          .map(([key, value]) => ({
-            id: key.split('/').pop(),
-            data: () => value
-          }))
-      }),
-      doc: (id: string) => ({
-        get: async () => ({
-          exists: this.data.has(`${path}/${id}`),
-          data: () => this.data.get(`${path}/${id}`)
-        }),
-        set: async (data: any) => {
-          this.data.set(`${path}/${id}`, data);
-        }
-      })
-    };
-  }
-}

package/src/tools/a2a-tools.ts

@@ -1,162 +0,0 @@
-/**
- * A2A Tools (Agent-to-Agent)
- * 
- * 3 tools for calling Cascade agents
- */
-
-import { ToolRegistry } from './tool-registry';
-import { CascadeA2AClient } from '../a2a-client';
-import { ToolResponse } from '../types';
-import { errorResponse, formatSuccess } from './response-helpers';
-
-export function registerA2ATools(registry: ToolRegistry, getA2aClient: () => Promise<CascadeA2AClient | null>): void {
-  // 1. cascade_run_explorer
-  registry.register({
-    name: 'cascade_run_explorer',
-    description: 'Launch Cascade Explorer agent to learn an application',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        app_name: {
-          type: 'string',
-          description: 'Application name to explore'
-        },
-        instructions: {
-          type: 'string',
-          description: 'Specific instructions for exploration'
-        },
-        max_steps: {
-          type: 'integer',
-          default: 50,
-          description: 'Maximum exploration steps'
-        }
-      },
-      required: ['app_name']
-    },
-    handler: async (args): Promise<ToolResponse> => {
-      try {
-        if (!args.app_name) {
-          return errorResponse('app_name is required');
-        }
-
-        await (await getA2aClient())?.sendToAgent('explorer', {
-          type: 'start_exploration',
-          appName: args.app_name,
-          instructions: args.instructions || `Learn how to use ${args.app_name}`,
-          maxSteps: args.max_steps || 50
-        });
-
-        return formatSuccess({
-          message: 'Explorer agent started',
-          app_name: args.app_name,
-          status: 'running'
-        });
-      } catch (error) {
-        return errorResponse(
-          error instanceof Error ? error.message : 'Failed to start explorer',
-          'Ensure A2A is enabled in configuration (enableA2A: true)'
-        );
-      }
-    }
-  });
-
-  // 2. cascade_run_worker
-  registry.register({
-    name: 'cascade_run_worker',
-    description: 'Execute a task using Cascade Worker agent',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        task: {
-          type: 'string',
-          description: 'Task description to execute'
-        },
-        skill_id: {
-          type: 'string',
-          description: 'Optional skill ID to use'
-        },
-        app_name: {
-          type: 'string',
-          description: 'Target application name'
-        },
-        inputs: {
-          type: 'object',
-          description: 'Optional inputs for the task',
-          additionalProperties: true
-        }
-      },
-      required: ['task']
-    },
-    handler: async (args): Promise<ToolResponse> => {
-      try {
-        if (!args.task) {
-          return errorResponse('task is required');
-        }
-
-        await (await getA2aClient())?.sendToAgent('worker', {
-          type: 'execute_task',
-          task: args.task,
-          skillId: args.skill_id,
-          appName: args.app_name,
-          inputs: args.inputs || {}
-        });
-
-        return formatSuccess({
-          message: 'Worker agent started',
-          task: args.task,
-          status: 'running'
-        });
-      } catch (error) {
-        return errorResponse(
-          error instanceof Error ? error.message : 'Failed to start worker',
-          'Ensure A2A is enabled in configuration (enableA2A: true)'
-        );
-      }
-    }
-  });
-
-  // 3. cascade_run_orchestrator
-  registry.register({
-    name: 'cascade_run_orchestrator',
-    description: 'Use Cascade Orchestrator to coordinate multi-step tasks',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        goal: {
-          type: 'string',
-          description: 'High-level goal to achieve'
-        },
-        require_approval: {
-          type: 'boolean',
-          default: true,
-          description: 'Require approval before executing steps'
-        }
-      },
-      required: ['goal']
-    },
-    handler: async (args): Promise<ToolResponse> => {
-      try {
-        if (!args.goal) {
-          return errorResponse('goal is required');
-        }
-
-        await (await getA2aClient())?.sendToAgent('orchestrator', {
-          type: 'coordinate',
-          goal: args.goal,
-          requireApproval: args.require_approval !== false
-        });
-
-        return formatSuccess({
-          message: 'Orchestrator started',
-          goal: args.goal,
-          status: 'running'
-        });
-      } catch (error) {
-        return errorResponse(
-          error instanceof Error ? error.message : 'Failed to start orchestrator',
-          'Ensure A2A is enabled in configuration (enableA2A: true)'
-        );
-      }
-    }
-  });
-}

package/src/tools/api-tools.ts

@@ -1,110 +0,0 @@
-/**
- * API Tools
- * 
- * 2 tools for web API calls and search
- */
-
-import { ToolRegistry } from './tool-registry';
-import { CascadeMcpClient } from '../cascade-client';
-import { ToolResponse } from '../types';
-import { errorResponse, formatSuccess } from './response-helpers';
-
-export function registerApiTools(registry: ToolRegistry, getClient: () => Promise<CascadeMcpClient>): void {
-  // 1. cascade_web_search
-  registry.register({
-    name: 'cascade_web_search',
-    description: 'Search the web for information',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        query: {
-          type: 'string',
-          description: 'Search query'
-        },
-        top_k: {
-          type: 'integer',
-          default: 5,
-          description: 'Number of results to return'
-        }
-      },
-      required: ['query']
-    },
-    handler: async (args): Promise<ToolResponse> => {
-      try {
-        if (!args.query) {
-          return errorResponse('query is required');
-        }
-
-        const result = await (await getClient()).callTool('web_search', {
-          query: args.query,
-          top_k: args.top_k || 5
-        });
-        return formatSuccess(result);
-      } catch (error) {
-        return errorResponse(
-          error instanceof Error ? error.message : 'Failed to search web',
-          'Check your network connection and API key if required'
-        );
-      }
-    }
-  });
-
-  // 2. cascade_call_http_api
-  registry.register({
-    name: 'cascade_call_http_api',
-    description: 'Execute an HTTP API request',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        method: {
-          type: 'string',
-          enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
-          description: 'HTTP method'
-        },
-        url: {
-          type: 'string',
-          description: 'Full URL to call'
-        },
-        headers: {
-          type: 'object',
-          description: 'Optional HTTP headers',
-          additionalProperties: { type: 'string' }
-        },
-        body: {
-          type: 'object',
-          description: 'Optional request body (as JSON)'
-        },
-        timeout: {
-          type: 'number',
-          default: 30,
-          description: 'Request timeout in seconds'
-        }
-      },
-      required: ['method', 'url']
-    },
-    handler: async (args): Promise<ToolResponse> => {
-      try {
-        if (!args.method) {
-          return errorResponse('method is required');
-        }
-        if (!args.url) {
-          return errorResponse('url is required');
-        }
-
-        const result = await (await getClient()).callTool('call_http_api', {
-          method: args.method,
-          url: args.url,
-          headers: args.headers,
-          body: args.body,
-          timeout: args.timeout || 30
-        });
-        return formatSuccess(result);
-      } catch (error) {
-        return errorResponse(
-          error instanceof Error ? error.message : 'Failed to call API',
-          'Verify the URL is correct and the API is accessible'
-        );
-      }
-    }
-  });
-}