Phase 2 & 3 Implementation Summary

Advanced Compiler-Compiler Platform

Phase 2 & 3 Implementation Summary

This document summarizes the implementation of Phase 2 (Core Implementation) and Phase 3 (Linux Electron Setup) for the Minotaur MAUI + Blazor Hybrid solution.

Phase 2: Core Implementation ✅

Phase 2 was completed prior to this work and includes:

Components Implemented

Features

Phase 3: Linux Electron Setup ✅

Phase 3 provides a native Linux desktop application wrapper for the Blazor UI.

Architecture

Minotaur Electron App
├── Main Process (main.js)
│   ├── Application lifecycle management
│   ├── Blazor Server startup/shutdown
│   ├── Native menu system
│   └── IPC handlers
├── Preload Script (preload.js)
│   ├── Secure IPC bridge
│   └── Context isolation
└── Renderer Process (renderer.js)
    ├── Blazor integration
    └── Menu event handling

Files Created

1. package.json

Key Dependencies:

Scripts:

2. main.js

Electron main process implementation with:

MinotaurElectronApp Class:

Menu System:

IPC Handlers:

Security Features:

3. preload.js

Secure IPC bridge with:

Exposed API via contextBridge:

window.electron = {
    showSaveDialog,
    showOpenDialog,
    getAppVersion,
    getAppName,
    isDevelopment,
    windowMinimize,
    windowMaximize,
    windowClose,
    onMenuEvent,
    removeMenuListener
}

Security:

4. renderer.js

Blazor-Electron integration layer:

Features:

Exposed Helpers:

window.electronHelpers = {
    showSaveDialog(defaultPath, title),
    showOpenDialog(title),
    getAppInfo()
}

Menu Events Handled:

5. README.md

Comprehensive documentation including:

6. INTEGRATION_GUIDE.md

Detailed integration guide with:

7. test-setup.sh

Automated verification script that checks:

8. start-dev.sh

Development launcher script:

9. .gitignore

Electron-specific ignore patterns:

10. assets/icon.png

Application icon (1.2MB) copied from main Minotaur logo

Build Targets

Linux Packages:

Build Commands:

npm run build-linux  # All Linux targets
npm run pack         # Directory output (faster for testing)
npm run dist         # Full distribution build

Keyboard Shortcuts

Action Shortcut
New Grammar Ctrl+N
Open Grammar Ctrl+O
Save Grammar Ctrl+S
Save Grammar As Ctrl+Shift+S
Find Ctrl+F
Replace Ctrl+H
Editor Tab Ctrl+1
Visualization Tab Ctrl+2
Debugging Tab Ctrl+3
Settings Tab Ctrl+4
Toggle Theme Ctrl+T
Parse Grammar F5
Generate Railroad F6
Validate Grammar F7
Generate Parse Tree F8
Format Grammar Ctrl+Shift+F
Quit Ctrl+Q

Security Implementation

Following Electron security best practices:

  1. Context Isolation: Enabled
  2. Node Integration: Disabled in renderer
  3. Preload Script: Controlled IPC exposure
  4. Web Security: Enabled
  5. External Links: Open in system browser
  6. Certificate Handling: Localhost-only exception
  7. Window Creation: Prevented, external links handled

Development Workflow

  1. Setup 
    cd src/Minotaur.UI.Electron
npm install
  2. Development 
    ./start-dev.sh
# or
npm run dev
  3. Testing 
    ./test-setup.sh
  4. Building 
    npm run build-linux

Integration with Blazor

The Electron app integrates with Blazor through:

  1. Automatic Server Management
    • Starts Blazor Server on app launch
    • Monitors server health
    • Graceful shutdown on app close
  2. IPC Communication
    • Menu events → Blazor methods
    • File dialogs → Native OS dialogs
    • App info → Version and environment
  3. Renderer Integration
    • renderer.js loaded in Blazor layout
    • Event handlers registered
    • Helper functions available

Testing Results

All verification checks pass:

Next Steps

For Developers

  1. Install Dependencies 
    cd src/Minotaur.UI.Electron
npm install
  2. Run in Development Mode 
    npm run dev
  3. Test the Integration
    • Verify all menu items work
    • Test keyboard shortcuts
    • Check file dialogs
    • Confirm Blazor UI loads
  4. Build Packages 
    npm run build-linux

For Integration

  1. Add renderer.js to Blazor
    • Copy to wwwroot/electron/
    • Reference in MainLayout.razor
  2. Create ElectronIntegrationService
    • Handle file operations
    • Detect Electron environment
    • Provide helper methods
  3. Implement Menu Handlers
    • Add JSInvokable methods
    • Register DotNet globally
    • Connect to UI actions
  4. Test Both Modes
    • Web browser (standalone)
    • Electron desktop app

Summary

Phase 3 successfully implements a production-ready Electron desktop application for Linux that:

The implementation is ready for testing and can be deployed as native Linux packages (AppImage, deb, rpm) for distribution.