openclaw-cascade-plugin 1.0.12 → 1.0.14

package/src/cascade-client.ts

@@ -1,198 +0,0 @@
-/**
- * Cascade MCP Client
- * 
- * Handles communication with Cascade MCP server via stdio JSON-RPC
- */
-
-import { spawn, ChildProcess } from 'child_process';
-
-export class CascadeMcpClient {
-  private process: ChildProcess | null = null;
-  private messageId = 0;
-  private pendingRequests = new Map<number, { resolve: Function; reject: Function }>();
-  private isInitialized = false;
-  private readonly REQUEST_TIMEOUT = 30000; // 30 seconds
-  private buffer = '';
-
-  constructor(
-    private pythonPath: string,
-    private env: NodeJS.ProcessEnv
-  ) {}
-
-  /**
-   * Start the MCP client and initialize connection
-   */
-  async start(): Promise<void> {
-    try {
-      // Spawn Cascade MCP server
-      this.process = spawn(this.pythonPath, ['-m', 'mcp_server.cli'], {
-        env: { ...process.env, ...this.env },
-        stdio: ['pipe', 'pipe', 'pipe']
-      });
-
-      // Handle stdout for JSON-RPC responses
-      if (this.process.stdout) {
-        this.process.stdout.on('data', (data: Buffer) => {
-          this.handleData(data.toString());
-        });
-      }
-
-      // Handle stderr
-      if (this.process.stderr) {
-        this.process.stderr.on('data', (data: Buffer) => {
-          console.error('Cascade MCP stderr:', data.toString());
-        });
-      }
-
-      // Handle process errors
-      this.process.on('error', (error: Error) => {
-        console.error('Cascade MCP process error:', error);
-        this.rejectAllPending(error);
-      });
-
-      // Initialize MCP connection
-      await this.sendRequest('initialize', {
-        protocolVersion: '2024-11-05',
-        capabilities: {},
-        clientInfo: { name: 'openclaw-cascade', version: '1.0.0' }
-      });
-
-      this.isInitialized = true;
-    } catch (error) {
-      this.stop();
-      throw error;
-    }
-  }
-
-  /**
-   * Call a tool by name with arguments
-   */
-  async callTool(name: string, args: Record<string, any>): Promise<any> {
-    if (!this.isInitialized) {
-      throw new Error('MCP client not initialized. Call start() first.');
-    }
-
-    return this.sendRequest('tools/call', { name, arguments: args });
-  }
-
-  /**
-   * List all available tools
-   */
-  async listTools(): Promise<any[]> {
-    if (!this.isInitialized) {
-      throw new Error('MCP client not initialized. Call start() first.');
-    }
-
-    const result = await this.sendRequest('tools/list', {});
-    return result.tools || [];
-  }
-
-  /**
-   * Check if client is connected
-   */
-  isConnected(): boolean {
-    return this.isInitialized && this.process !== null && !this.process.killed;
-  }
-
-  /**
-   * Stop the MCP client
-   */
-  stop(): void {
-    this.rejectAllPending(new Error('Client stopped'));
-    
-    if (this.process && !this.process.killed) {
-      this.process.kill();
-    }
-    
-    this.process = null;
-    this.isInitialized = false;
-    this.buffer = '';
-  }
-
-  /**
-   * Handle incoming data from stdout
-   */
-  private handleData(data: string): void {
-    this.buffer += data;
-    
-    // Process complete lines
-    const lines = this.buffer.split('\n');
-    this.buffer = lines.pop() || ''; // Keep incomplete line in buffer
-    
-    for (const line of lines) {
-      if (line.trim()) {
-        this.handleResponse(line);
-      }
-    }
-  }
-
-  /**
-   * Send a JSON-RPC request
-   */
-  private async sendRequest(method: string, params: any): Promise<any> {
-    const id = ++this.messageId;
-    const request = { jsonrpc: '2.0', id, method, params };
-
-    return new Promise((resolve, reject) => {
-      // Set timeout
-      const timeoutId = setTimeout(() => {
-        this.pendingRequests.delete(id);
-        reject(new Error(`Request ${method} timed out after ${this.REQUEST_TIMEOUT}ms`));
-      }, this.REQUEST_TIMEOUT);
-
-      // Store pending request
-      this.pendingRequests.set(id, {
-        resolve: (result: any) => {
-          clearTimeout(timeoutId);
-          resolve(result);
-        },
-        reject: (error: Error) => {
-          clearTimeout(timeoutId);
-          reject(error);
-        }
-      });
-
-      // Send request
-      if (this.process?.stdin) {
-        this.process.stdin.write(JSON.stringify(request) + '\n');
-      } else {
-        this.pendingRequests.delete(id);
-        clearTimeout(timeoutId);
-        reject(new Error('Process stdin not available'));
-      }
-    });
-  }
-
-  /**
-   * Handle incoming JSON-RPC response
-   */
-  private handleResponse(line: string): void {
-    try {
-      const response = JSON.parse(line);
-      
-      if (response.id && this.pendingRequests.has(response.id)) {
-        const { resolve, reject } = this.pendingRequests.get(response.id)!;
-        this.pendingRequests.delete(response.id);
-
-        if (response.error) {
-          reject(new Error(response.error.message || 'Unknown error'));
-        } else {
-          resolve(response.result);
-        }
-      }
-    } catch (e) {
-      // Ignore parse errors for non-JSON lines
-      console.debug('Failed to parse MCP response:', line.substring(0, 100));
-    }
-  }
-
-  /**
-   * Reject all pending requests
-   */
-  private rejectAllPending(error: Error): void {
-    for (const [_id, { reject }] of this.pendingRequests) {
-      reject(error);
-    }
-    this.pendingRequests.clear();
-  }
-}

package/src/config.test.ts

@@ -1,189 +0,0 @@
-/**
- * Tests for Config
- */
-
-import { loadConfig, validateConfig, getDefaults } from './config';
-import { CascadePluginConfig } from './types';
-
-describe('Config', () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    process.env = { ...originalEnv };
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  describe('getDefaults', () => {
-    test('should return default configuration', async () => {
-      // Act
-      const defaults = await getDefaults();
-
-      // Assert
-      expect(defaults).toEqual({
-        cascadeGrpcEndpoint: 'localhost:50051',
-        headless: false,
-        actionTimeoutMs: 8000,
-        enableA2A: true,
-        verbose: false,
-        screenshotMode: 'auto'
-      });
-    });
-  });
-
-  describe('validateConfig', () => {
-    test('should pass with valid config', async () => {
-      // Arrange
-      const config: CascadePluginConfig = {
-        cascadeGrpcEndpoint: 'localhost:50051'
-      };
-
-      // Act & Assert
-      expect(() => validateConfig(config)).not.toThrow();
-    });
-
-    test('should throw when cascadeGrpcEndpoint is missing', async () => {
-      // Arrange
-      const config: CascadePluginConfig = {} as any;
-
-      // Act & Assert
-      expect(() => validateConfig(config)).toThrow('cascadeGrpcEndpoint is required');
-    });
-
-    test('should throw when cascadeGrpcEndpoint is empty', async () => {
-      // Arrange
-      const config: CascadePluginConfig = {
-        cascadeGrpcEndpoint: ''
-      };
-
-      // Act & Assert
-      expect(() => validateConfig(config)).toThrow('cascadeGrpcEndpoint is required');
-    });
-
-    test('should validate firestore credentials path if provided', async () => {
-      // Arrange
-      const config: CascadePluginConfig = {
-        cascadeGrpcEndpoint: 'localhost:50051',
-        firestoreCredentialsPath: '/path/to/creds.json'
-      };
-
-      // Act & Assert
-      expect(() => validateConfig(config)).not.toThrow();
-    });
-
-    test('should validate allowed agents', async () => {
-      // Arrange
-      const config: CascadePluginConfig = {
-        cascadeGrpcEndpoint: 'localhost:50051',
-        allowedAgents: ['explorer', 'worker', 'orchestrator']
-      };
-
-      // Act & Assert
-      expect(() => validateConfig(config)).not.toThrow();
-    });
-
-    test('should throw for invalid agent in allowedAgents', async () => {
-      // Arrange
-      const config: any = {
-        cascadeGrpcEndpoint: 'localhost:50051',
-        allowedAgents: ['explorer', 'invalid-agent']
-      };
-
-      // Act & Assert
-      expect(() => validateConfig(config)).toThrow('Invalid agent');
-    });
-
-    test('should validate screenshotMode', async () => {
-      // Arrange
-      const config: CascadePluginConfig = {
-        cascadeGrpcEndpoint: 'localhost:50051',
-        screenshotMode: 'embed'
-      };
-
-      // Act & Assert
-      expect(() => validateConfig(config)).not.toThrow();
-    });
-
-    test('should throw for invalid screenshotMode', async () => {
-      // Arrange
-      const config: any = {
-        cascadeGrpcEndpoint: 'localhost:50051',
-        screenshotMode: 'invalid'
-      };
-
-      // Act & Assert
-      expect(() => validateConfig(config)).toThrow('Invalid screenshotMode');
-    });
-  });
-
-  describe('loadConfig', () => {
-    test('should load config with defaults when input is empty', async () => {
-      // Act
-      const config = await loadConfig({});
-
-      // Assert
-      expect(config.cascadeGrpcEndpoint).toBe('localhost:50051');
-      expect(config.headless).toBe(false);
-      expect(config.actionTimeoutMs).toBe(8000);
-    });
-
-    test('should merge with provided values', async () => {
-      // Arrange
-      const input = {
-        cascadeGrpcEndpoint: '192.168.1.100:50051',
-        headless: true,
-        actionTimeoutMs: 15000
-      };
-
-      // Act
-      const config = await loadConfig(input);
-
-      // Assert
-      expect(config.cascadeGrpcEndpoint).toBe('192.168.1.100:50051');
-      expect(config.headless).toBe(true);
-      expect(config.actionTimeoutMs).toBe(15000);
-    });
-
-    test('should expand environment variables in paths', async () => {
-      // Arrange
-      process.env.HOME = '/home/user';
-      const input = {
-        cascadeGrpcEndpoint: 'localhost:50051',
-        firestoreCredentialsPath: '$HOME/creds.json'
-      };
-
-      // Act
-      const config = await loadConfig(input);
-
-      // Assert
-      expect(config.firestoreCredentialsPath).toBe('/home/user/creds.json');
-    });
-
-    test('should handle Windows environment variables', async () => {
-      // Arrange
-      process.env.USERPROFILE = 'C:\\Users\\TestUser';
-      const input = {
-        cascadeGrpcEndpoint: 'localhost:50051',
-        cascadePythonPath: '%USERPROFILE%\\Python\\python.exe'
-      };
-
-      // Act
-      const config = await loadConfig(input);
-
-      // Assert
-      expect(config.cascadePythonPath).toBe('C:\\Users\\TestUser\\Python\\python.exe');
-    });
-
-    test('should validate loaded config', async () => {
-      // Arrange
-      const input = {
-        cascadeGrpcEndpoint: ''
-      };
-
-      // Act & Assert
-      await expect(loadConfig(input as any)).rejects.toThrow('cascadeGrpcEndpoint is required');
-    });
-  });
-});

package/src/config.ts

@@ -1,137 +0,0 @@
-/**
- * Configuration management for OpenClaw Cascade Plugin
- */
-
-import { CascadePluginConfig } from './types';
-import { isWsl, getWslHostIp } from './wsl';
-
-const VALID_AGENTS = ['explorer', 'worker', 'orchestrator'];
-const VALID_SCREENSHOT_MODES = ['embed', 'disk', 'auto'];
-
-/**
- * Get default configuration values
- */
-export async function getDefaults(): Promise<Partial<CascadePluginConfig>> {
-  let defaultEndpoint = 'localhost:50051';
-  
-  if (isWsl()) {
-    const wslIp = await getWslHostIp();
-    if (wslIp) {
-      defaultEndpoint = `${wslIp}:50051`;
-    }
-  }
-
-  return {
-    cascadeGrpcEndpoint: defaultEndpoint,
-    headless: false,
-    actionTimeoutMs: 8000,
-    enableA2A: true,
-    verbose: false,
-    screenshotMode: 'auto'
-  };
-}
-
-/**
- * Validate configuration object
- */
-export function validateConfig(config: CascadePluginConfig): void {
-  // Required fields
-  if (!config.cascadeGrpcEndpoint || config.cascadeGrpcEndpoint.trim() === '') {
-    throw new Error('cascadeGrpcEndpoint is required');
-  }
-
-  // Validate gRPC endpoint format
-  const endpointPattern = /^[\w.-]+:\d+$/;
-  if (!endpointPattern.test(config.cascadeGrpcEndpoint)) {
-    throw new Error(
-      `Invalid cascadeGrpcEndpoint format: ${config.cascadeGrpcEndpoint}. ` +
-      'Expected format: host:port (e.g., localhost:50051)'
-    );
-  }
-
-  // Validate allowed agents if provided
-  if (config.allowedAgents) {
-    for (const agent of config.allowedAgents) {
-      if (!VALID_AGENTS.includes(agent)) {
-        throw new Error(`Invalid agent in allowedAgents: ${agent}. Valid agents: ${VALID_AGENTS.join(', ')}`);
-      }
-    }
-  }
-
-  // Validate screenshot mode if provided
-  if (config.screenshotMode && !VALID_SCREENSHOT_MODES.includes(config.screenshotMode)) {
-    throw new Error(
-      `Invalid screenshotMode: ${config.screenshotMode}. ` +
-      `Valid modes: ${VALID_SCREENSHOT_MODES.join(', ')}`
-    );
-  }
-
-  // Validate action timeout
-  if (config.actionTimeoutMs !== undefined && config.actionTimeoutMs < 1000) {
-    throw new Error('actionTimeoutMs must be at least 1000ms');
-  }
-}
-
-/**
- * Expand environment variables in a string
- * Supports both $VAR and %VAR% syntax
- */
-export function expandEnvVars(value: string): string {
-  if (!value) return value;
-
-  // Unix-style: $VAR or ${VAR}
-  let expanded = value.replace(/\$\{(\w+)\}/g, (match, varName) => {
-    return process.env[varName] || match;
-  });
-
-  expanded = expanded.replace(/\$(\w+)/g, (match, varName) => {
-    return process.env[varName] || match;
-  });
-
-  // Windows-style: %VAR%
-  expanded = expanded.replace(/%(\w+)%/g, (match, varName) => {
-    return process.env[varName] || match;
-  });
-
-  return expanded;
-}
-
-/**
- * Load and validate configuration
- */
-export async function loadConfig(input?: Partial<CascadePluginConfig>): Promise<CascadePluginConfig> {
-  const actualInput = input || {};
-
-  // Expand environment variables in string fields
-  const expanded: Partial<CascadePluginConfig> = {};
-  
-  for (const [key, value] of Object.entries(actualInput)) {
-    if (typeof value === 'string') {
-      (expanded as any)[key] = expandEnvVars(value);
-    } else {
-      (expanded as any)[key] = value;
-    }
-  }
-
-  // Merge with defaults
-  const defaults = await getDefaults();
-  const config: CascadePluginConfig = {
-    ...defaults,
-    ...expanded
-  } as CascadePluginConfig;
-
-  // Validate
-  validateConfig(config);
-
-  return config;
-}
-
-/**
- * Load configuration from OpenClaw API
- */
-export async function loadConfigFromOpenClaw(api: any): Promise<CascadePluginConfig> {
-  const entries = api.config?.plugins?.entries || {};
-  const pluginConfig = entries['openclaw-cascade-plugin']?.config || entries.cascade?.config || {};
-  
-  return loadConfig(pluginConfig);
-}