openclaw-cascade-plugin 1.0.12 → 1.0.14

package/src/index.ts

@@ -1,202 +0,0 @@
-/**
- * OpenClaw Plugin Entry Point
- * 
- * This is the main entry point for the @cascade/openclaw-plugin
- * It initializes the plugin and registers all tools with OpenClaw
- */
-
-import { PythonManager } from './python-manager';
-import { CascadeMcpClient } from './cascade-client';
-import { CascadeA2AClient } from './a2a-client';
-import { loadConfig } from './config';
-import { CascadeError } from './types';
-import { delimiter as pathDelimiter } from 'path';
-import {
-  registerDesktopTools,
-  registerWebTools,
-  registerApiTools,
-  registerSandboxTools,
-  registerA2ATools
-} from './tools';
-import { ToolRegistry } from './tools/tool-registry';
-
-// Placeholder for OpenClaw API type
-interface OpenClawApi {
-  config: {
-    plugins: {
-      entries: {
-        cascade?: { config?: any };
-        'openclaw-cascade-plugin'?: { config?: any };
-        [key: string]: { config?: any } | undefined;
-      };
-    };
-  };
-  registerTool: (tool: any) => void;
-  registerGatewayMethod: (name: string, handler: Function) => void;
-  registerCli: (handler: Function) => void;
-  notify: (message: string) => void;
-}
-
-export default async function register(api: OpenClawApi) {
-  let mcpClient: CascadeMcpClient | null = null;
-  let a2aClient: CascadeA2AClient | null = null;
-
-  try {
-    // Load and validate configuration
-    const entries = api.config.plugins.entries || {};
-    const config = await loadConfig(
-      entries['openclaw-cascade-plugin']?.config ||
-      entries.cascade?.config ||
-      {}
-    );
-    
-    // Lazy loaded clients
-    let pythonPath: string | null = null;
-    let initialized = false;
-
-    const getMcpClient = async (): Promise<CascadeMcpClient> => {
-      if (mcpClient && initialized) return mcpClient;
-
-      // Initialize Python Manager
-      const pythonManager = new PythonManager(config);
-      pythonPath = await pythonManager.findOrInstallPython();
-      
-      // Initialize MCP Client
-      const pythonEnv: NodeJS.ProcessEnv = {
-        CASCADE_GRPC_ENDPOINT: config.cascadeGrpcEndpoint,
-        CASCADE_APP_ID: config.firestoreProjectId || 'openclaw',
-        CASCADE_USER_ID: 'openclaw-user',
-        ...(config.firestoreCredentialsPath && {
-          GOOGLE_APPLICATION_CREDENTIALS: config.firestoreCredentialsPath
-        })
-      };
-
-      let modulePath = config.cascadePythonModulePath || process.env.CASCADE_PYTHON_MODULE_PATH;
-      
-      // Auto-detect Cascade python module path relative to plugin installation
-      if (!modulePath) {
-        const { join } = require('path');
-        const { existsSync } = require('fs');
-        // __dirname is openclaw-plugin/dist
-        // repo root python is openclaw-plugin/../python
-        const guessedPath = join(__dirname, '..', '..', 'python');
-        if (existsSync(join(guessedPath, 'mcp_server', '__init__.py'))) {
-          modulePath = guessedPath;
-        }
-      }
-
-      if (modulePath) {
-        const existingPath = process.env.PYTHONPATH || '';
-        pythonEnv.PYTHONPATH = existingPath
-          ? `${modulePath}${pathDelimiter}${existingPath}`
-          : modulePath;
-      }
-
-      mcpClient = new CascadeMcpClient(pythonPath, pythonEnv);
-      await mcpClient.start();
-      initialized = true;
-      return mcpClient;
-    };
-
-    const getA2aClient = async (): Promise<CascadeA2AClient | null> => {
-      if (!config.enableA2A) return null;
-      if (a2aClient) return a2aClient;
-
-      a2aClient = new CascadeA2AClient(
-        config.cascadeGrpcEndpoint,
-        'openclaw-user',
-        config.firestoreProjectId || 'openclaw',
-        '' // auth token would come from config
-      );
-      await a2aClient.initialize();
-      return a2aClient;
-    };
-    
-    // Create tool registry
-    const toolRegistry = new ToolRegistry();
-    
-    // Register all tools using the getters
-    registerDesktopTools(toolRegistry, getMcpClient, config);
-    registerWebTools(toolRegistry, getMcpClient);
-    registerApiTools(toolRegistry, getMcpClient);
-    registerSandboxTools(toolRegistry, getMcpClient);
-    registerA2ATools(toolRegistry, getA2aClient);
-    
-    // Register tools with OpenClaw
-    const tools = toolRegistry.getAll();
-    
-    for (const tool of tools) {
-      // Ensure the schema is perfectly formatted for OpenAI and OpenClaw's internal validator
-      const schema = tool.inputSchema || { type: 'object', properties: {} };
-      
-      api.registerTool({
-        name: tool.name,
-        description: tool.description,
-        schema: schema,
-        parameters: schema,
-        inputSchema: schema,
-        // Match the exact signature expected by OpenClaw's pi-agent-core AgentTool
-        execute: async (_toolCallId: string, params: any) => tool.handler(params), 
-        handler: tool.handler  // Fallback for legacy
-      });
-    }
-    
-    // Register status check
-    api.registerGatewayMethod('cascade.status', () => ({
-      connected: mcpClient?.isConnected() || false,
-      toolsRegistered: tools.length,
-      pythonPath,
-      grpcEndpoint: config.cascadeGrpcEndpoint,
-      a2aEnabled: config.enableA2A
-    }));
-    
-    // Register CLI command
-    api.registerCli(({ program }: { program: any }) => {
-      program
-        .command('cascade:status')
-        .description('Check Cascade plugin status')
-        .action(async () => {
-          let connected = false;
-          try {
-             // Only check if it's already initialized to avoid triggering init
-             if (initialized && mcpClient) {
-                connected = mcpClient.isConnected();
-             }
-          } catch(e) {}
-
-          console.log('Cascade Plugin Status:');
-          console.log('  Connected:', connected);
-          console.log('  Tools:', tools.length);
-          console.log('  Python:', pythonPath || 'Not yet initialized');
-          console.log('  gRPC:', config.cascadeGrpcEndpoint);
-          console.log('  A2A:', config.enableA2A ? 'enabled' : 'disabled');
-        });
-      
-      program
-        .command('cascade:tools')
-        .description('List all registered tools')
-        .action(() => {
-          console.log('Registered Tools:');
-          tools.forEach((tool, index) => {
-            console.log(`  ${index + 1}. ${tool.name}`);
-          });
-        });
-    });
-    
-  } catch (error) {
-    console.error('Failed to initialize Cascade plugin:', error);
-    
-    if (error instanceof CascadeError) {
-      throw error;
-    }
-    
-    throw new Error(
-      `Cascade plugin initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-    );
-  }
-}
-
-// Export types for TypeScript users
-export * from './types';
-export { PythonManager, CascadeMcpClient, CascadeA2AClient, loadConfig };
-// Note: ToolRegistry is internal use only - not exported to avoid conflicts

package/src/python-manager.test.ts

@@ -1,187 +0,0 @@
-/**
- * Tests for PythonManager
- * 
- * Test-driven development: Write tests first, then implement
- */
-
-import { PythonManager } from './python-manager';
-import { createMockConfig } from './test-utils';
-
-describe('PythonManager', () => {
-  let pythonManager: PythonManager;
-  let mockExec: jest.Mock;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockExec = jest.fn();
-    
-    // Mock the exec method directly on the module
-    jest.doMock('child_process', () => ({
-      exec: mockExec
-    }));
-    
-    pythonManager = new PythonManager(createMockConfig());
-  });
-
-  afterEach(() => {
-    jest.dontMock('child_process');
-  });
-
-  describe('findOrInstallPython', () => {
-    test('should return configured path when cascadePythonPath is set', async () => {
-      // Arrange
-      const config = createMockConfig({ cascadePythonPath: '/custom/python' });
-      pythonManager = new PythonManager(config);
-      
-      // Mock the execAsync method directly
-      const execSpy = jest.spyOn(pythonManager as any, 'execAsync')
-        .mockResolvedValue({ stdout: 'Python 3.12.0', stderr: '' });
-
-      // Act
-      const result = await pythonManager.findOrInstallPython();
-
-      // Assert
-      expect(result).toBe('/custom/python');
-      expect(execSpy).toHaveBeenCalledWith('/custom/python --version');
-    });
-
-    test('should auto-detect python3.12 in common locations', async () => {
-      // Arrange
-      let callCount = 0;
-      const execSpy = jest.spyOn(pythonManager as any, 'execAsync')
-        .mockImplementation(() => {
-          callCount++;
-          if (callCount <= 2) {
-            return Promise.reject(new Error('not found'));
-          }
-          return Promise.resolve({ stdout: 'Python 3.10.0', stderr: '' });
-        });
-
-      // Act
-      const result = await pythonManager.findOrInstallPython();
-
-      // Assert
-      expect(result).toBe('python3.10');
-      expect(execSpy).toHaveBeenCalledWith('python3.12 --version');
-      expect(execSpy).toHaveBeenCalledWith('python3.11 --version');
-      expect(execSpy).toHaveBeenCalledWith('python3.10 --version');
-    });
-
-    test('should fallback through version candidates in order', async () => {
-      // Arrange
-      jest.spyOn(pythonManager as any, 'execAsync')
-        .mockResolvedValue({ stdout: 'Python 3.12.1', stderr: '' });
-
-      // Act
-      const result = await pythonManager.findOrInstallPython();
-
-      // Assert
-      expect(result).toBe('python3.12');
-    });
-
-    test('should throw error when no Python found and auto-install fails', async () => {
-      // Arrange
-      jest.spyOn(pythonManager as any, 'execAsync').mockRejectedValue(new Error('not found'));
-      
-      // Mock install to fail
-      jest.spyOn(pythonManager as any, 'installPython').mockRejectedValue(
-        new Error('Installation failed')
-      );
-
-      // Act & Assert
-      await expect(pythonManager.findOrInstallPython()).rejects.toThrow('Installation failed');
-    });
-  });
-
-  describe('isValidPython', () => {
-    test('should return true for Python 3.10+', async () => {
-      // Arrange
-      jest.spyOn(pythonManager as any, 'execAsync')
-        .mockResolvedValue({ stdout: 'Python 3.12.0', stderr: '' });
-
-      // Act
-      const result = await (pythonManager as any).isValidPython('python3');
-
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    test('should return true for Python 3.10.x', async () => {
-      // Arrange
-      jest.spyOn(pythonManager as any, 'execAsync')
-        .mockResolvedValue({ stdout: 'Python 3.10.5', stderr: '' });
-
-      // Act
-      const result = await (pythonManager as any).isValidPython('python3');
-
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    test('should return false for Python 3.9', async () => {
-      // Arrange
-      jest.spyOn(pythonManager as any, 'execAsync')
-        .mockResolvedValue({ stdout: 'Python 3.9.7', stderr: '' });
-
-      // Act
-      const result = await (pythonManager as any).isValidPython('python3');
-
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('should return false for Python 2.x', async () => {
-      // Arrange
-      jest.spyOn(pythonManager as any, 'execAsync')
-        .mockResolvedValue({ stdout: 'Python 2.7.18', stderr: '' });
-
-      // Act
-      const result = await (pythonManager as any).isValidPython('python');
-
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('should return false for non-Python executables', async () => {
-      // Arrange
-      jest.spyOn(pythonManager as any, 'execAsync')
-        .mockResolvedValue({ stdout: 'not python output', stderr: '' });
-
-      // Act
-      const result = await (pythonManager as any).isValidPython('notpython');
-
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    test('should return false when command not found', async () => {
-      // Arrange
-      jest.spyOn(pythonManager as any, 'execAsync')
-        .mockRejectedValue(new Error('command not found'));
-
-      // Act
-      const result = await (pythonManager as any).isValidPython('fakepython');
-
-      // Assert
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('parsePythonVersion', () => {
-    test('should parse standard version output', () => {
-      // Act & Assert
-      expect((pythonManager as any).parsePythonVersion('Python 3.12.0')).toBe(3.12);
-      expect((pythonManager as any).parsePythonVersion('Python 3.10.5')).toBe(3.10);
-      expect((pythonManager as any).parsePythonVersion('Python 3.9.0')).toBe(3.09);
-    });
-
-    test('should handle version without patch', () => {
-      expect((pythonManager as any).parsePythonVersion('Python 3.12')).toBe(3.12);
-    });
-
-    test('should return 0 for invalid output', () => {
-      expect((pythonManager as any).parsePythonVersion('not python')).toBe(0);
-      expect((pythonManager as any).parsePythonVersion('')).toBe(0);
-    });
-  });
-});

package/src/python-manager.ts

@@ -1,230 +0,0 @@
-/**
- * Python Manager - Handles Python environment detection and installation
- */
-
-import { exec } from 'child_process';
-import { join } from 'path';
-import { CascadePluginConfig } from './types';
-
-export class PythonManager {
-  private readonly MIN_PYTHON_VERSION = 3.10;
-  
-  constructor(private config: CascadePluginConfig) {}
-
-  /**
-   * Find or install Python for Cascade
-   * Priority: 1) Configured path 2) Auto-detect 3) Auto-install
-   */
-  async findOrInstallPython(): Promise<string> {
-    // 1. Check configured path
-    if (this.config.cascadePythonPath) {
-      if (await this.isValidPython(this.config.cascadePythonPath)) {
-        return this.config.cascadePythonPath;
-      }
-      console.warn(`Configured Python path ${this.config.cascadePythonPath} is not valid, searching...`);
-    }
-
-    // 2. Auto-detect in common locations
-    const detected = await this.autoDetectPython();
-    if (detected) {
-      return detected;
-    }
-
-    // 3. Auto-install
-    console.log('Python not found. Installing...');
-    return this.installPython();
-  }
-
-  /**
-   * Auto-detect Python in common locations
-   */
-  private async autoDetectPython(): Promise<string | null> {
-    const candidates = this.getPythonCandidates();
-    
-    for (const cmd of candidates) {
-      if (await this.isValidPython(cmd)) {
-        return cmd;
-      }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Get list of Python commands to try
-   */
-  private getPythonCandidates(): string[] {
-    const candidates = [
-      'python3.12',
-      'python3.11', 
-      'python3.10',
-      'python3',
-    ];
-
-    if (process.platform === 'win32') {
-      // Windows-specific paths
-      const localAppData = process.env.LOCALAPPDATA || '';
-      const programFiles = process.env.ProgramFiles || '';
-      
-      candidates.push(
-        join(localAppData, 'Programs', 'Python', 'Python312', 'python.exe'),
-        join(localAppData, 'Programs', 'Python', 'Python311', 'python.exe'),
-        join(localAppData, 'Programs', 'Python', 'Python310', 'python.exe'),
-        join(programFiles, 'Python312', 'python.exe'),
-        join(programFiles, 'Python311', 'python.exe'),
-        join(programFiles, 'Python310', 'python.exe'),
-        'python.exe',
-        'python'
-      );
-    } else {
-      // Unix-like paths
-      candidates.push(
-        '/usr/bin/python3.12',
-        '/usr/bin/python3.11',
-        '/usr/bin/python3.10',
-        '/usr/bin/python3',
-        '/usr/local/bin/python3.12',
-        '/usr/local/bin/python3.11',
-        '/usr/local/bin/python3.10',
-        '/usr/local/bin/python3',
-        '/opt/homebrew/bin/python3.12',
-        '/opt/homebrew/bin/python3.11',
-        '/opt/homebrew/bin/python3.10',
-        '/opt/homebrew/bin/python3'
-      );
-    }
-
-    return candidates;
-  }
-
-  /**
-   * Check if Python command is valid and meets version requirements
-   */
-  async isValidPython(cmd: string): Promise<boolean> {
-    try {
-      const { stdout } = await this.execAsync(`${cmd} --version`);
-      const version = this.parsePythonVersion(stdout);
-      return version >= this.MIN_PYTHON_VERSION;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Parse Python version from version string
-   */
-  parsePythonVersion(versionOutput: string): number {
-    const match = versionOutput.match(/Python (\d+)\.(\d+)/);
-    if (!match) return 0;
-    
-    const major = parseInt(match[1], 10);
-    const minor = parseInt(match[2], 10);
-    return major + minor / 100;
-  }
-
-  /**
-   * Execute command and return stdout
-   */
-  private execAsync(command: string): Promise<{ stdout: string; stderr: string }> {
-    return new Promise((resolve, reject) => {
-      exec(command, (error, stdout, stderr) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve({ stdout, stderr });
-        }
-      });
-    });
-  }
-
-  /**
-   * Auto-install Python based on platform
-   */
-  private async installPython(): Promise<string> {
-    if (process.platform === 'win32') {
-      return this.installPythonWindows();
-    } else if (process.platform === 'darwin') {
-      return this.installPythonMacOS();
-    } else {
-      return this.installPythonLinux();
-    }
-  }
-
-  /**
-   * Install Python on Windows
-   */
-  private async installPythonWindows(): Promise<string> {
-    try {
-      const installerPath = await this.downloadPythonInstaller();
-      await this.runPythonInstaller(installerPath);
-      return 'python';
-    } catch (error) {
-      throw new Error(
-        `Failed to install Python on Windows: ${error instanceof Error ? error.message : 'Unknown error'}. ` +
-        'Please install Python 3.10+ manually from https://python.org'
-      );
-    }
-  }
-
-  /**
-   * Download Python installer for Windows
-   */
-  private async downloadPythonInstaller(): Promise<string> {
-    // In production, this would download from python.org
-    // For now, we assume the user needs to install manually
-    throw new Error('Automatic installation not implemented. Please install Python manually.');
-  }
-
-  /**
-   * Run Python installer on Windows
-   */
-  private async runPythonInstaller(installerPath: string): Promise<void> {
-    await this.execAsync(`"${installerPath}" /quiet InstallAllUsers=0 PrependPath=1`);
-  }
-
-  /**
-   * Install Python on macOS using Homebrew
-   */
-  private async installPythonMacOS(): Promise<string> {
-    // Check if brew is available
-    try {
-      await this.execAsync('which brew');
-    } catch {
-      throw new Error(
-        'Homebrew not found. Please install Homebrew first: https://brew.sh'
-      );
-    }
-
-    try {
-      await this.execAsync('brew install python@3.12');
-      return '/usr/local/bin/python3.12';
-    } catch (error) {
-      throw new Error(
-        `Failed to install Python via Homebrew: ${error instanceof Error ? error.message : 'Unknown error'}`
-      );
-    }
-  }
-
-  /**
-   * Install Python on Linux using apt
-   */
-  private async installPythonLinux(): Promise<string> {
-    // Check if apt is available
-    try {
-      await this.execAsync('which apt');
-    } catch {
-      throw new Error(
-        'apt not found. Please install Python 3.10+ manually using your package manager.'
-      );
-    }
-
-    try {
-      await this.execAsync('sudo apt-get update && sudo apt-get install -y python3.12 python3.12-venv');
-      return '/usr/bin/python3.12';
-    } catch (error) {
-      throw new Error(
-        `Failed to install Python via apt: ${error instanceof Error ? error.message : 'Unknown error'}`
-      );
-    }
-  }
-}