crca 1.4.0__py3-none-any.whl

tools/bolt.diy/services/headless-executor/executor.ts

@@ -0,0 +1,210 @@
+/**
+ * Core execution logic for headless browser mandate execution.
+ * 
+ * Uses Playwright to control a browser and execute mandates via WebContainer.
+ */
+
+import { chromium, Browser, Page, BrowserContext } from 'playwright';
+import type { Mandate, ExecutionEvent, ExecutionResult } from './types.js';
+
+export interface ExecutorConfig {
+  boltDiyUrl: string;
+  governorUrl: string;
+  workerId: string;
+  headless: boolean;
+  timeout: number;
+}
+
+export class HeadlessExecutor {
+  private browser: Browser | null = null;
+  private context: BrowserContext | null = null;
+  private config: ExecutorConfig;
+  private activePages: Map<string, Page> = new Map();
+
+  constructor(config: ExecutorConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Initialize browser and context.
+   */
+  async initialize(): Promise<void> {
+    if (this.browser) {
+      return; // Already initialized
+    }
+
+    this.browser = await chromium.launch({
+      headless: this.config.headless !== false,
+      args: [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        '--disable-dev-shm-usage',
+        '--disable-accelerated-2d-canvas',
+        '--disable-gpu',
+      ],
+    });
+
+    this.context = await this.browser.newContext({
+      viewport: { width: 1920, height: 1080 },
+      ignoreHTTPSErrors: true,
+    });
+
+    console.log('Headless browser initialized');
+  }
+
+  /**
+   * Execute a mandate in headless browser.
+   */
+  async executeMandate(mandate: Mandate): Promise<ExecutionResult> {
+    if (!this.browser || !this.context) {
+      await this.initialize();
+    }
+
+    if (!this.context) {
+      throw new Error('Browser context not initialized');
+    }
+
+    const page = await this.context.newPage();
+    this.activePages.set(mandate.mandate_id, page);
+
+    try {
+      // Navigate to execution page
+      const executionUrl = `${this.config.boltDiyUrl}/execute/${mandate.mandate_id}`;
+      console.log(`Navigating to ${executionUrl}`);
+      
+      await page.goto(executionUrl, {
+        waitUntil: 'networkidle',
+        timeout: 30000,
+      });
+
+      // Wait for page to load and start execution
+      await page.waitForSelector('#root', { timeout: 10000 });
+
+      // Inject mandate data into page
+      await page.evaluate((mandateData) => {
+        (window as any).__MANDATE_DATA__ = mandateData;
+      }, mandate);
+
+      // Wait for execution to complete
+      // The page will auto-execute and emit events
+      const result = await this.waitForExecutionComplete(page, mandate.mandate_id);
+
+      return result;
+    } catch (error) {
+      console.error(`Error executing mandate ${mandate.mandate_id}:`, error);
+      throw error;
+    } finally {
+      await page.close();
+      this.activePages.delete(mandate.mandate_id);
+    }
+  }
+
+  /**
+   * Wait for execution to complete and collect result.
+   */
+  private async waitForExecutionComplete(
+    page: Page,
+    mandateId: string
+  ): Promise<ExecutionResult> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Execution timeout for mandate ${mandateId}`));
+      }, this.config.timeout);
+
+      // Listen for execution completion event
+      page.on('console', async (msg) => {
+        const text = msg.text();
+        if (text.includes('EXECUTION_COMPLETE')) {
+          clearTimeout(timeout);
+          try {
+            // Get result from page
+            const result = await page.evaluate(() => {
+              return (window as any).__EXECUTION_RESULT__;
+            });
+
+            if (result) {
+              resolve(result);
+            } else {
+              reject(new Error('Execution completed but no result found'));
+            }
+          } catch (error) {
+            reject(error);
+          }
+        } else if (text.includes('EXECUTION_ERROR')) {
+          clearTimeout(timeout);
+          const error = await page.evaluate(() => {
+            return (window as any).__EXECUTION_ERROR__;
+          });
+          reject(new Error(error || 'Execution failed'));
+        }
+      });
+
+      // Also check for completion via DOM
+      const checkInterval = setInterval(async () => {
+        try {
+          const status = await page.evaluate(() => {
+            const statusEl = document.querySelector('[data-execution-status]');
+            return statusEl?.getAttribute('data-execution-status');
+          });
+
+          if (status === 'completed' || status === 'failed') {
+            clearInterval(checkInterval);
+            clearTimeout(timeout);
+
+            const result = await page.evaluate(() => {
+              return (window as any).__EXECUTION_RESULT__;
+            });
+
+            if (result) {
+              resolve(result);
+            } else {
+              // Create result from status
+              resolve({
+                mandate_id: mandateId,
+                status: status === 'completed' ? 'success' : 'failed',
+                iterations_completed: 0,
+                final_state: {},
+                governance_summary: {},
+                budget_summary: {
+                  tokens_used: 0,
+                  time_elapsed: 0,
+                  cost_incurred: 0,
+                  budget_remaining: { tokens: 0, time: 0, cost: 0 },
+                },
+                events: [],
+                created_at: Date.now(),
+                completed_at: Date.now(),
+              });
+            }
+          }
+        } catch (error) {
+          // Continue checking
+        }
+      }, 1000);
+    });
+  }
+
+  /**
+   * Cleanup browser and context.
+   */
+  async cleanup(): Promise<void> {
+    // Close all active pages
+    for (const page of this.activePages.values()) {
+      await page.close().catch(() => {});
+    }
+    this.activePages.clear();
+
+    if (this.context) {
+      await this.context.close();
+      this.context = null;
+    }
+
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+    }
+
+    console.log('Headless browser cleaned up');
+  }
+}
+

tools/bolt.diy/services/headless-executor/index.ts

@@ -0,0 +1,323 @@
+/**
+ * Headless Executor Worker Service
+ * 
+ * Connects to Execution Governor and executes mandates using Playwright.
+ */
+
+import { WebSocket } from 'ws';
+import { HeadlessExecutor, type ExecutorConfig } from './executor.js';
+import type { Mandate, ExecutionEvent } from './types.js';
+
+const GOVERNOR_URL = process.env.GOVERNOR_URL || 'http://localhost:3000';
+const BOLT_DIY_URL = process.env.BOLT_DIY_URL || 'http://localhost:5173';
+const WORKER_ID = process.env.WORKER_ID || `worker-${Date.now()}`;
+const MAX_CONCURRENT = parseInt(process.env.MAX_CONCURRENT || '1', 10);
+const POLL_INTERVAL = parseInt(process.env.POLL_INTERVAL || '5000', 10);
+
+const config: ExecutorConfig = {
+  boltDiyUrl: BOLT_DIY_URL,
+  governorUrl: GOVERNOR_URL,
+  workerId: WORKER_ID,
+  headless: process.env.HEADLESS !== 'false',
+  timeout: parseInt(process.env.EXECUTION_TIMEOUT || '3600000', 10), // 1 hour default
+};
+
+const executor = new HeadlessExecutor(config);
+let isRunning = false;
+let currentExecutions = 0;
+let ws: WebSocket | null = null;
+
+/**
+ * Register worker with governor.
+ */
+async function registerWorker(): Promise<boolean> {
+  try {
+    const response = await fetch(`${GOVERNOR_URL}/workers/register`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        workerId: WORKER_ID,
+        capabilities: {
+          maxConcurrent: MAX_CONCURRENT,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      console.error(`Failed to register worker: ${response.statusText}`);
+      return false;
+    }
+
+    const result = await response.json();
+    console.log(`Worker registered: ${result.message}`);
+    return true;
+  } catch (error) {
+    console.error('Error registering worker:', error);
+    return false;
+  }
+}
+
+/**
+ * Send heartbeat to governor.
+ */
+async function sendHeartbeat(): Promise<void> {
+  try {
+    await fetch(`${GOVERNOR_URL}/workers/${WORKER_ID}/heartbeat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        status: currentExecutions > 0 ? 'busy' : 'idle',
+      }),
+    });
+  } catch (error) {
+    console.error('Error sending heartbeat:', error);
+  }
+}
+
+/**
+ * Request next mandate from governor.
+ */
+async function requestMandate(): Promise<Mandate | null> {
+  try {
+    const response = await fetch(`${GOVERNOR_URL}/workers/${WORKER_ID}/request-mandate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const data = await response.json();
+    if (!data.mandate_id) {
+      return null;
+    }
+
+    // Fetch full mandate details
+    const mandateResponse = await fetch(`${GOVERNOR_URL}/mandates/${data.mandate_id}`);
+    if (!mandateResponse.ok) {
+      return null;
+    }
+
+    const mandateData = await mandateResponse.json();
+    return mandateData.mandate;
+  } catch (error) {
+    console.error('Error requesting mandate:', error);
+    return null;
+  }
+}
+
+/**
+ * Report execution progress to governor.
+ */
+async function reportProgress(
+  mandateId: string,
+  event: ExecutionEvent,
+  progress?: number
+): Promise<void> {
+  try {
+    await fetch(`${GOVERNOR_URL}/workers/${WORKER_ID}/report-progress`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        mandateId,
+        event,
+        progress,
+      }),
+    });
+  } catch (error) {
+    console.error('Error reporting progress:', error);
+  }
+}
+
+/**
+ * Report execution completion to governor.
+ */
+async function reportCompletion(
+  mandateId: string,
+  success: boolean,
+  result?: any,
+  error?: string
+): Promise<void> {
+  try {
+    await fetch(`${GOVERNOR_URL}/workers/${WORKER_ID}/complete`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        mandateId,
+        success,
+        result,
+        error,
+      }),
+    });
+  } catch (error) {
+    console.error('Error reporting completion:', error);
+  }
+}
+
+/**
+ * Execute a mandate.
+ */
+async function executeMandate(mandate: Mandate): Promise<void> {
+  currentExecutions++;
+  const startTime = Date.now();
+
+  console.log(`Starting execution of mandate ${mandate.mandate_id}`);
+
+  try {
+    // Initialize executor if needed
+    await executor.initialize();
+
+    // Report start
+    await reportProgress(mandate.mandate_id, {
+      mandate_id: mandate.mandate_id,
+      iteration: 0,
+      type: 'iteration_start',
+      timestamp: Date.now(),
+      data: { status: 'running' },
+      metadata: {},
+    });
+
+    // Execute mandate
+    const result = await executor.executeMandate(mandate);
+
+    const duration = Date.now() - startTime;
+    console.log(
+      `Mandate ${mandate.mandate_id} ${result.status} in ${duration}ms`
+    );
+
+    // Report completion
+    await reportCompletion(mandate.mandate_id, result.status === 'success', result);
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`Mandate ${mandate.mandate_id} failed:`, errorMessage);
+
+    // Report failure
+    await reportCompletion(mandate.mandate_id, false, undefined, errorMessage);
+  } finally {
+    currentExecutions--;
+  }
+}
+
+/**
+ * Main worker loop.
+ */
+async function workerLoop(): Promise<void> {
+  while (isRunning) {
+    try {
+      // Check if we can accept more work
+      if (currentExecutions >= MAX_CONCURRENT) {
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+        continue;
+      }
+
+      // Request mandate
+      const mandate = await requestMandate();
+      if (!mandate) {
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+        continue;
+      }
+
+      // Execute mandate (don't await - run in parallel)
+      executeMandate(mandate).catch((error) => {
+        console.error(`Error in mandate execution:`, error);
+      });
+    } catch (error) {
+      console.error('Error in worker loop:', error);
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+    }
+  }
+}
+
+/**
+ * Connect to governor WebSocket for real-time updates.
+ */
+function connectWebSocket(): void {
+  const wsUrl = GOVERNOR_URL.replace('http://', 'ws://').replace('https://', 'wss://');
+  ws = new WebSocket(wsUrl);
+
+  ws.on('open', () => {
+    console.log('Connected to governor WebSocket');
+  });
+
+  ws.on('message', (data: Buffer) => {
+    try {
+      const message = JSON.parse(data.toString());
+      if (message.type === 'mandate_assigned' && message.mandate) {
+        // Governor pushed a mandate - execute it
+        if (currentExecutions < MAX_CONCURRENT) {
+          executeMandate(message.mandate).catch((error) => {
+            console.error(`Error executing pushed mandate:`, error);
+          });
+        }
+      }
+    } catch (error) {
+      console.error('Error handling WebSocket message:', error);
+    }
+  });
+
+  ws.on('error', (error) => {
+    console.error('WebSocket error:', error);
+  });
+
+  ws.on('close', () => {
+    console.log('WebSocket closed, reconnecting...');
+    setTimeout(connectWebSocket, 5000);
+  });
+}
+
+/**
+ * Initialize and start worker.
+ */
+async function start(): Promise<void> {
+  console.log(`Starting headless executor worker ${WORKER_ID}`);
+  console.log(`Governor URL: ${GOVERNOR_URL}`);
+  console.log(`Bolt.diy URL: ${BOLT_DIY_URL}`);
+  console.log(`Max concurrent: ${MAX_CONCURRENT}`);
+
+  // Register with governor
+  const registered = await registerWorker();
+  if (!registered) {
+    console.error('Failed to register worker, exiting');
+    process.exit(1);
+  }
+
+  // Connect WebSocket
+  connectWebSocket();
+
+  // Start heartbeat
+  setInterval(sendHeartbeat, 30000); // Every 30 seconds
+
+  // Start worker loop
+  isRunning = true;
+  workerLoop().catch((error) => {
+    console.error('Worker loop error:', error);
+    process.exit(1);
+  });
+}
+
+/**
+ * Graceful shutdown.
+ */
+async function shutdown(): Promise<void> {
+  console.log('Shutting down worker...');
+  isRunning = false;
+
+  if (ws) {
+    ws.close();
+  }
+
+  await executor.cleanup();
+  process.exit(0);
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+
+// Start worker
+start().catch((error) => {
+  console.error('Failed to start worker:', error);
+  process.exit(1);
+});
+

tools/bolt.diy/services/headless-executor/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "headless-executor",
+  "version": "1.0.0",
+  "description": "Headless browser worker for executing mandates with WebContainer",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "dev": "tsx watch index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "playwright": "^1.41.0",
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/ws": "^8.5.10",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  }
+}
+

tools/bolt.diy/services/headless-executor/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "lib": ["ES2022"],
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}
+

tools/bolt.diy/services/headless-executor/types.ts

@@ -0,0 +1,38 @@
+/**
+ * Type definitions for Headless Executor
+ */
+
+export interface Mandate {
+  mandate_id: string;
+  objectives: string[];
+  constraints: any;
+  budget: any;
+  deliverables: string[];
+  governance?: any;
+  iteration_config: any;
+  deployment?: any;
+}
+
+export interface ExecutionEvent {
+  mandate_id: string;
+  iteration: number;
+  type: string;
+  timestamp: number;
+  data: Record<string, any>;
+  metadata?: Record<string, any>;
+}
+
+export interface ExecutionResult {
+  mandate_id: string;
+  status: "success" | "failed" | "stopped" | "timeout" | "budget_exceeded";
+  iterations_completed: number;
+  final_state: any;
+  governance_summary: any;
+  budget_summary: any;
+  deployment_result?: any;
+  errors?: any[];
+  events: ExecutionEvent[];
+  created_at: number;
+  completed_at: number;
+}
+