Arcas OnlineEDA MCP Server

Instructions

Implementation Reference

• src/tools/run-verification.ts:30-88 (handler)

  The protected execute method implements the core tool logic: ensures login, navigates to the project verification page, selects verification type, configures options, starts and waits for verification, extracts results using browser automation.

  protected async execute(params: RunVerificationParams): Promise<ToolResult> {
    await this.ensureLoggedIn();
    
    const page = this.browserManager.getPage();
    if (!page) {
      return {
        success: false,
        error: 'Browser page not available',
      };
    }
  
    try {
      // Navigate to project verification page
      await page.goto(`https://onlineeda.arcas-da.com/projects/${params.projectId}/verify`, { 
        waitUntil: 'networkidle2' 
      });
      
      // Select verification type
      await page.select('select[name="verificationType"], #verificationType', params.verificationType);
      
      // Configure options if provided
      if (params.options) {
        if (params.options.timeout) {
          await page.type('input[name="timeout"], #timeout', params.options.timeout.toString());
        }
        if (params.options.depth) {
          await page.type('input[name="depth"], #depth', params.options.depth.toString());
        }
      }
      
      // Start verification
      await Promise.all([
        page.click('button.run-verification, button[type="submit"]'),
        page.waitForSelector('.verification-running, .progress-indicator', { timeout: 5000 }),
      ]);
      
      // Wait for verification to complete
      await page.waitForSelector('.verification-complete, .results-ready', { 
        timeout: (params.options?.timeout || 300) * 1000 
      });
      
      // Extract results
      const results = await this.extractVerificationResults(page);
      
      return {
        success: true,
        data: {
          projectId: params.projectId,
          verificationType: params.verificationType,
          results,
        },
      };
    } catch (error) {
      return {
        success: false,
        error: `Verification failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
      };
    }
  }

• src/tools/run-verification.ts:5-13 (schema)

  Zod schema defining the input parameters for the tool: projectId (required), verificationType (enum), and optional options object.

  const RunVerificationSchema = z.object({
    projectId: z.string().describe('Project ID to run verification on'),
    verificationType: z.enum(['formal', 'equivalence', 'power', 'security', 'fpga']).describe('Type of verification to run'),
    options: z.object({
      timeout: z.number().optional().describe('Verification timeout in seconds'),
      depth: z.number().optional().describe('Verification depth for formal methods'),
      properties: z.array(z.string()).optional().describe('Specific properties to verify'),
    }).optional(),
  });

• src/index.ts:52-64 (registration)

  The setupTools method instantiates all tools including RunVerificationTool and registers them in the tools Map using their getName() method.

  private setupTools(): void {
    const toolInstances = [
      new NavigateTool(this.browserManager),
      new ProjectTool(this.browserManager),
      new UploadFileTool(this.browserManager),
      new RunVerificationTool(this.browserManager),
      new NaturalLanguageTool(this.browserManager),
    ];
  
    for (const tool of toolInstances) {
      this.tools.set(tool.getName(), tool);
    }
  }

• src/tools/run-verification.ts:90-117 (helper)

  Private helper method to extract verification results from the browser page using DOM selectors and evaluation.

  private async extractVerificationResults(page: any): Promise<VerificationResult> {
    const results = await page.evaluate(() => {
      // Extract verification results from page (selectors need adjustment)
      const passed = document.querySelector('.verification-passed, .status-passed') !== null;
      
      const violations = Array.from(document.querySelectorAll('.violation-item, .error-item')).map((el: any) => ({
        type: el.querySelector('.violation-type')?.textContent?.trim() || 'unknown',
        message: el.querySelector('.violation-message')?.textContent?.trim() || '',
        location: el.querySelector('.violation-location')?.textContent?.trim(),
        severity: el.querySelector('.violation-severity')?.textContent?.trim() || 'error',
      }));
      
      const stats = {
        totalChecks: parseInt(document.querySelector('.total-checks')?.textContent || '0'),
        passed: parseInt(document.querySelector('.checks-passed')?.textContent || '0'),
        failed: parseInt(document.querySelector('.checks-failed')?.textContent || '0'),
        warnings: parseInt(document.querySelector('.warnings-count')?.textContent || '0'),
      };
      
      return {
        passed,
        violations,
        statistics: stats,
      };
    });
    
    return results;
  }