openclaw-cascade-plugin 1.0.12 → 1.0.14

package/scripts/postinstall.js

@@ -1,84 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const PLUGIN_ID = 'openclaw-cascade-plugin';
-const DEFAULT_ENDPOINT = 'localhost:50051';
-const defaultConfigPath = path.join(os.homedir(), '.openclaw', 'openclaw.json');
-const legacyConfigPath = path.join(os.homedir(), '.openclaw', 'config.json');
-const configPath = process.env.OPENCLAW_CONFIG_PATH ||
-  (fs.existsSync(defaultConfigPath) ? defaultConfigPath : legacyConfigPath);
-
-function readConfig(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return { plugins: { entries: {} } };
-  }
-
-  const content = fs.readFileSync(filePath, 'utf8');
-  try {
-    return JSON.parse(content);
-  } catch (error) {
-    console.warn('[cascade] Could not parse OpenClaw config; skipping auto-update:', error.message);
-    return null;
-  }
-}
-
-function writeConfig(filePath, config) {
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-
-  fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
-}
-
-function ensurePluginEntry(config) {
-  config.plugins = config.plugins || {};
-  config.plugins.entries = config.plugins.entries || {};
-
-  // Migrate legacy entry if present
-  if (config.plugins.entries.cascade && !config.plugins.entries[PLUGIN_ID]) {
-    config.plugins.entries[PLUGIN_ID] = config.plugins.entries.cascade;
-    delete config.plugins.entries.cascade;
-  }
-
-  const entry = config.plugins.entries[PLUGIN_ID] || {};
-  const existingConfig = entry.config || {};
-
-  const cascadeRepoPath = process.env.CASCADE_REPO_PATH;
-  const cascadePythonModulePath = process.env.CASCADE_PYTHON_MODULE_PATH ||
-    (cascadeRepoPath ? path.join(cascadeRepoPath, 'python') : undefined);
-
-  config.plugins.entries[PLUGIN_ID] = {
-    enabled: entry.enabled !== false,
-    config: {
-      cascadeGrpcEndpoint: existingConfig.cascadeGrpcEndpoint || DEFAULT_ENDPOINT,
-      cascadePythonModulePath: existingConfig.cascadePythonModulePath || cascadePythonModulePath,
-      cascadePythonPath: existingConfig.cascadePythonPath,
-      firestoreProjectId: existingConfig.firestoreProjectId,
-      firestoreCredentialsPath: existingConfig.firestoreCredentialsPath,
-      headless: existingConfig.headless,
-      actionTimeoutMs: existingConfig.actionTimeoutMs,
-      enableA2A: existingConfig.enableA2A,
-      allowedAgents: existingConfig.allowedAgents,
-      requireAgentConfirmation: existingConfig.requireAgentConfirmation,
-      verbose: existingConfig.verbose,
-      screenshotMode: existingConfig.screenshotMode,
-      screenshotDir: existingConfig.screenshotDir
-    }
-  };
-}
-
-const config = readConfig(configPath);
-if (!config) {
-  process.exit(0);
-}
-
-ensurePluginEntry(config);
-writeConfig(configPath, config);
-
-console.log(`[cascade] OpenClaw config updated: ${configPath}`);
-console.log('[cascade] Plugin entry ensured under plugins.entries.openclaw-cascade-plugin');
-if (!process.env.CASCADE_REPO_PATH && !process.env.CASCADE_PYTHON_MODULE_PATH) {
-  console.log('[cascade] Tip: set CASCADE_REPO_PATH to your repo to auto-configure PYTHONPATH.');
-}

package/src/a2a-client.ts

@@ -1,66 +0,0 @@
-/**
- * A2A Client - Agent-to-Agent communication
- */
-
-import { A2AMessage } from './types';
-
-export class CascadeA2AClient {
-  private agentId: string | null = null;
-  private messageHandlers = new Map<string, (payload: any) => Promise<void>>();
-  private grpcEndpoint: string;
-  private userId: string;
-  private appId: string;
-  private authToken: string;
-
-  constructor(
-    grpcEndpoint: string,
-    userId: string,
-    appId: string,
-    authToken: string
-  ) {
-    this.grpcEndpoint = grpcEndpoint;
-    this.userId = userId;
-    this.appId = appId;
-    this.authToken = authToken;
-  }
-
-  async initialize(): Promise<void> {
-    // Initialize gRPC connection and register agent
-    // This is a placeholder - actual implementation would use gRPC
-    this.agentId = `openclaw-${this.userId}-${Date.now()}`;
-    console.debug(`A2A Client connecting to ${this.grpcEndpoint} for app ${this.appId}`);
-  }
-
-  async sendToAgent(
-    targetRole: 'explorer' | 'worker' | 'orchestrator',
-    payload: any,
-    targetAgentId?: string
-  ): Promise<void> {
-    if (!this.agentId) {
-      throw new Error('A2A client not initialized');
-    }
-
-    const message: A2AMessage = {
-      type: payload.type,
-      source: 'openclaw',
-      timestamp: Date.now(),
-      payload,
-      runId: payload.runId
-    };
-
-    // Send via gRPC (placeholder)
-    const target = targetAgentId || targetRole;
-    console.log(`Sending message to ${target}:`, message);
-    
-    // In real implementation, would use this.grpcEndpoint and this.authToken
-    console.debug(`Using endpoint: ${this.grpcEndpoint}, token: ${this.authToken ? '***' : 'none'}`);
-  }
-
-  onMessage(type: string, handler: (payload: any) => Promise<void>): void {
-    this.messageHandlers.set(type, handler);
-  }
-
-  isConnected(): boolean {
-    return this.agentId !== null;
-  }
-}

package/src/cascade-client.test.ts

@@ -1,400 +0,0 @@
-/**
- * Tests for CascadeMcpClient
- * 
- * MCP (Model Context Protocol) client for communicating with Cascade
- */
-
-import { CascadeMcpClient } from './cascade-client';
-import { createMockConfig } from './test-utils';
-import { spawn } from 'child_process';
-import { EventEmitter } from 'events';
-
-// Mock child_process
-jest.mock('child_process');
-
-describe('CascadeMcpClient', () => {
-  let client: CascadeMcpClient;
-  let mockProcess: any;
-  let mockSpawn: jest.MockedFunction<typeof spawn>;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    
-    // Create mock process
-    const stdout = new EventEmitter();
-    const stderr = new EventEmitter();
-    const stdin = { write: jest.fn() };
-    
-    mockProcess = {
-      stdout,
-      stderr,
-      stdin,
-      kill: jest.fn(),
-      on: jest.fn(),
-      pid: 12345,
-      killed: false
-    };
-
-    mockSpawn = spawn as jest.MockedFunction<typeof spawn>;
-    mockSpawn.mockReturnValue(mockProcess as any);
-
-    const config = createMockConfig({
-      cascadePythonPath: '/usr/bin/python3',
-      cascadeGrpcEndpoint: 'localhost:50051'
-    });
-
-    client = new CascadeMcpClient(
-      config.cascadePythonPath!,
-      {
-        CASCADE_GRPC_ENDPOINT: config.cascadeGrpcEndpoint,
-        CASCADE_APP_ID: 'test-app',
-        CASCADE_USER_ID: 'test-user'
-      }
-    );
-  });
-
-  describe('start', () => {
-    test('should spawn Python MCP server', async () => {
-      // Arrange
-      const startPromise = client.start();
-      
-      // Emit initialize response
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 1,
-          result: {
-            protocolVersion: '2024-11-05',
-            capabilities: {},
-            serverInfo: { name: 'cascade-mcp', version: '1.0.0' }
-          }
-        }) + '\n');
-      }, 10);
-
-      // Act
-      await startPromise;
-
-      // Assert
-      expect(mockSpawn).toHaveBeenCalledWith(
-        '/usr/bin/python3',
-        ['-m', 'mcp_server.cli'],
-        expect.objectContaining({
-          env: expect.objectContaining({
-            CASCADE_GRPC_ENDPOINT: 'localhost:50051',
-            CASCADE_APP_ID: 'test-app',
-            CASCADE_USER_ID: 'test-user'
-          }),
-          stdio: ['pipe', 'pipe', 'pipe']
-        })
-      );
-    });
-
-    test('should send initialize request', async () => {
-      // Arrange
-      const startPromise = client.start();
-      
-      // Emit initialize response
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 1,
-          result: {
-            protocolVersion: '2024-11-05',
-            capabilities: {},
-            serverInfo: { name: 'cascade-mcp', version: '1.0.0' }
-          }
-        }) + '\n');
-      }, 10);
-
-      // Act
-      await startPromise;
-
-      // Assert
-      const writeCalls = mockProcess.stdin.write.mock.calls;
-      const initRequest = JSON.parse(writeCalls[0][0]);
-      
-      expect(initRequest).toMatchObject({
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'initialize',
-        params: {
-          protocolVersion: '2024-11-05',
-          clientInfo: { name: 'openclaw-cascade', version: '1.0.0' }
-        }
-      });
-    });
-
-    test('should throw when spawn fails', async () => {
-      // Arrange
-      mockSpawn.mockImplementation(() => {
-        throw new Error('Spawn failed');
-      });
-
-      // Act & Assert
-      await expect(client.start()).rejects.toThrow('Spawn failed');
-    });
-
-    test('should timeout if no response', async () => {
-      // Arrange - don't emit any response
-
-      // Act & Assert
-      await expect(client.start()).rejects.toThrow('timed out');
-    }, 35000); // 35 second timeout for this test
-  });
-
-  describe('callTool', () => {
-    beforeEach(async () => {
-      // Start client first
-      const startPromise = client.start();
-      
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 1,
-          result: {
-            protocolVersion: '2024-11-05',
-            capabilities: {},
-            serverInfo: { name: 'cascade-mcp', version: '1.0.0' }
-          }
-        }) + '\n');
-      }, 10);
-
-      await startPromise;
-    });
-
-    test('should send tool/call request', async () => {
-      // Arrange
-      const callPromise = client.callTool('click_element', { id: 'button1' });
-      
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 2,
-          result: { success: true }
-        }) + '\n');
-      }, 10);
-
-      // Act
-      await callPromise;
-
-      // Assert
-      const writeCalls = mockProcess.stdin.write.mock.calls;
-      const lastCall = writeCalls[writeCalls.length - 1][0];
-      const request = JSON.parse(lastCall);
-      
-      expect(request).toMatchObject({
-        jsonrpc: '2.0',
-        id: 2,
-        method: 'tools/call',
-        params: {
-          name: 'click_element',
-          arguments: { id: 'button1' }
-        }
-      });
-    });
-
-    test('should return tool result', async () => {
-      // Arrange
-      const callPromise = client.callTool('get_screenshot', {});
-      
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 2,
-          result: { image: 'base64data', format: 'PNG' }
-        }) + '\n');
-      }, 10);
-
-      // Act
-      const result = await callPromise;
-
-      // Assert
-      expect(result).toEqual({ image: 'base64data', format: 'PNG' });
-    });
-
-    test('should handle tool errors', async () => {
-      // Arrange
-      const callPromise = client.callTool('click_element', { id: 'nonexistent' });
-      
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 2,
-          error: { code: -32602, message: 'Element not found' }
-        }) + '\n');
-      }, 10);
-
-      // Act & Assert
-      await expect(callPromise).rejects.toThrow('Element not found');
-    });
-
-    test('should timeout after 30 seconds', async () => {
-      // Arrange - don't emit any response
-      
-      // Act & Assert
-      await expect(client.callTool('click_element', {})).rejects.toThrow('timed out');
-    }, 35000); // 35 second timeout for this test
-  });
-
-  describe('listTools', () => {
-    beforeEach(async () => {
-      const startPromise = client.start();
-      
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 1,
-          result: {
-            protocolVersion: '2024-11-05',
-            capabilities: {},
-            serverInfo: { name: 'cascade-mcp', version: '1.0.0' }
-          }
-        }) + '\n');
-      }, 10);
-
-      await startPromise;
-    });
-
-    test('should return list of available tools', async () => {
-      // Arrange
-      const listPromise = client.listTools();
-      
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 2,
-          result: {
-            tools: [
-              { name: 'click_element', description: 'Click element' },
-              { name: 'get_screenshot', description: 'Get screenshot' }
-            ]
-          }
-        }) + '\n');
-      }, 10);
-
-      // Act
-      const result = await listPromise;
-
-      // Assert
-      expect(result).toHaveLength(2);
-      expect(result[0].name).toBe('click_element');
-      expect(result[1].name).toBe('get_screenshot');
-    });
-
-    test('should handle empty tool list', async () => {
-      // Arrange
-      const listPromise = client.listTools();
-      
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 2,
-          result: { tools: [] }
-        }) + '\n');
-      }, 10);
-
-      // Act
-      const result = await listPromise;
-
-      // Assert
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('error handling', () => {
-    test('should handle JSON parse errors gracefully', async () => {
-      // Arrange
-      const startPromise = client.start();
-      
-      setTimeout(() => {
-        // Emit invalid JSON first
-        mockProcess.stdout.emit('data', 'not valid json\n');
-        
-        // Then emit valid response
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 1,
-          result: {
-            protocolVersion: '2024-11-05',
-            capabilities: {},
-            serverInfo: { name: 'cascade-mcp', version: '1.0.0' }
-          }
-        }) + '\n');
-      }, 10);
-
-      // Act - should not throw
-      await expect(startPromise).resolves.not.toThrow();
-    });
-
-    test('should handle process crash', async () => {
-      // Arrange
-      const startPromise = client.start();
-      
-      setTimeout(() => {
-        const errorHandler = mockProcess.on.mock.calls.find(
-          (call: any) => call[0] === 'error'
-        )?.[1];
-        if (errorHandler) {
-          errorHandler(new Error('Process crashed'));
-        }
-      }, 10);
-
-      // Act & Assert
-      await expect(startPromise).rejects.toThrow('Process crashed');
-    });
-
-    test('should reject all pending on error', async () => {
-      // Arrange
-      const startPromise = client.start();
-      
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 1,
-          result: { protocolVersion: '2024-11-05' }
-        }) + '\n');
-      }, 10);
-
-      await startPromise;
-
-      // Start a tool call that will hang
-      const toolPromise = client.callTool('click_element', {});
-
-      // Emit error
-      setTimeout(() => {
-        const errorHandler = mockProcess.on.mock.calls.find(
-          (call: any) => call[0] === 'error'
-        )?.[1];
-        if (errorHandler) {
-          errorHandler(new Error('Connection lost'));
-        }
-      }, 10);
-
-      // Act & Assert
-      await expect(toolPromise).rejects.toThrow('Connection lost');
-    });
-  });
-
-  describe('stop', () => {
-    test('should kill the process', async () => {
-      // Arrange
-      const startPromise = client.start();
-      
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 1,
-          result: { protocolVersion: '2024-11-05' }
-        }) + '\n');
-      }, 10);
-
-      await startPromise;
-
-      // Act
-      client.stop();
-
-      // Assert
-      expect(mockProcess.kill).toHaveBeenCalled();
-    });
-  });
-});