ELIMS Platform Architecture & Integration Roadmap

Extensible Lightweight Integrated Modular System

ELIMS: The Platform Vision

ELIMS (elims.org) serves as the extensible foundation where any control system can become a tentacle of the Firebreathing Jellyfish. Each plugin adds another impossible capability, creating an ecosystem limited only by imagination.

Founding Elements (Initial Integration)

1. 🌊 ELIMS Core - Water element (The pure platform/ocean, no application logic)
2. 🌍 MusicBee Plugin - Earth element (The gravitational center, carries more weight)
3. 💨 slPhantomRemote - Air element (halrad.com/slPhantomTray) (sound waves, disrupting silence)
4. 🔥 ToteRemote - Fire element (halrad.com/Toteremote) (visual, bright screens)
5. 💎 Pixelblaze - Crystal element (LED control, up to 5000 pixels)

Current Architecture Analysis

Integration Architecture

Recommended Approach: Elemental Integration

Based on the assessment, I recommend a phased elemental approach where each element maintains its nature while harmonizing:

1. Phase 1: IPC Bridge Mode (Quick Win)
   • Keep applications running independently
   • Create thin plugin wrappers
   • Use Named Pipes for communication
   • Minimal code changes required
2. Phase 2: Service Extraction (Medium Term)
   • Extract core services as shared libraries
   • Create plugin implementations using services
   • Maintain backward compatibility
3. Phase 3: Full Plugin Integration (Long Term)
   • Complete UI integration as native tabs
   • Unified configuration management
   • Shared resource optimization

Detailed Integration Plan

Phase 1: IPC Bridge Implementation (2-3 weeks)

1.1 Create Plugin Wrappers

PhantomRemotePlugin for slPhantomRemote:

namespace RemoteViewer.Plugins.Phantom
{
    public class PhantomRemotePlugin : IVolumeControlPlugin
    {
        private Process? _phantomProcess;
        private NamedPipeClientStream? _pipeClient;
        private Panel? _container;
        
        public string PluginId => "PhantomSpeakers";
        public string DisplayName => "Phantom Speakers";
        public string TabIcon => "🔊";
        public bool HandlesVolumeControl => true;
        public int VolumeControlPriority => 10;
        
        public Control CreateTabContent()
        {
            _container = new Panel { Dock = DockStyle.Fill };
            
            // Option A: Embedded window
            LaunchPhantomRemote();
            EmbedWindow();
            
            // Option B: Custom UI that communicates via IPC
            // CreateCustomUI();
            
            return _container;
        }
        
        private void LaunchPhantomRemote()
        {
            _phantomProcess = Process.Start(new ProcessStartInfo
            {
                FileName = "slPhantomRemote.exe",
                Arguments = "uimode:embedded --ipc-server",
                UseShellExecute = false
            });
        }
    }
}

ToteRemotePlugin for ToteRemote:

namespace RemoteViewer.Plugins.TV
{
    public class ToteRemotePlugin : IVolumeControlPlugin
    {
        private CommandControl? _commandControl;
        private ToteRemotePanel? _panel;
        
        public string PluginId => "TVRemote";
        public string DisplayName => "TV Control";
        public string TabIcon => "📺";
        public bool HandlesVolumeControl => true;
        public int VolumeControlPriority => 5;
        
        public Control CreateTabContent()
        {
            _panel = new ToteRemotePanel();
            _commandControl = new CommandControl(
                Settings.ToteRemoteIP, 
                Settings.ToteRemotePort
            );
            
            _panel.OnCommand += (cmd) => _commandControl.SendCommand(cmd);
            
            return _panel;
        }
    }
}

1.2 IPC Protocol Definition

{
  "command": "SET_VOLUME",
  "params": {
    "volume": 50,
    "source": "TNTCTL"
  }
}

{
  "command": "GET_NOW_PLAYING",
  "response": {
    "artist": "Artist Name",
    "title": "Track Title",
    "source": "Spotify",
    "volume": 50,
    "isPlaying": true
  }
}

1.3 Modifications Required

slPhantomRemote:

• Add --ipc-server command line option
• Implement NamedPipeServer in Program.cs
• Add embedded mode UI adjustments
• Expose service methods via IPC

ToteRemote:

• Extract CommandControl to shared library
• Create ToteRemotePanel UserControl
• Remove standalone-only features
• Add plugin configuration support

ELIMS Core:

• Already has plugin loading in MainForm
• Implement volume routing to active plugin
• Add tab switching logic
• Let plugins provide Now Playing info

Implementation Stages

Stage 1: Foundation (Week 1)

• ☐ Create plugin project structure
• ☐ Implement basic IPlugin for each app
• ☐ Test plugin loading in TNTCTL
• ☐ Verify .NET compatibility

Stage 2: IPC Bridge (Week 2-3)

• ☐ Implement IPC server in slPhantomRemote
• ☐ Create IPC client in plugin wrapper
• ☐ Add embedded mode support
• ☐ Test communication

Stage 3: ToteRemote Integration (Week 3-4)

• ☐ Extract CommandControl class
• ☐ Create TV control panel
• ☐ Implement volume routing
• ☐ Test TV control functions

Stage 4: Volume Unification (Week 4-5)

• ☐ Implement volume routing service
• ☐ Add source detection
• ☐ Create priority system
• ☐ Test multi-source scenarios

Stage 5: Polish & Testing (Week 5-6)

• ☐ Unified configuration system
• ☐ Consistent theming
• ☐ Error handling
• ☐ Performance optimization
• ☐ User documentation

Platform Extensibility Vision

The Five Founding Elements

1. 🌊 Water (ELIMS Core) - The pure platform/ocean hosting everything, no preferences, no logic
2. 🌍 Earth (MusicBee Plugin) - The gravitational center of music, extracted from core, carries more weight
3. 💨 Air (slPhantomRemote) - Phantom speaker control, disrupting silence
4. 🔥 Fire (ToteRemote) - TV/display control via "WiFIR Blaster"
5. 💎 Crystal (Pixelblaze Plugin) - ElectroMage LED control for up to 5000 pixels of sparkle

Conclusion

ELIMS transcends being merely an integration of three applications - it's an extensible platform for the militantly impossible. The architecture supports expansion through:

1. Standardized Plugin Interface - Developers can create new elements
2. Elemental Philosophy - Each plugin represents a force of nature or concept
3. Practical Growth - Add plugins as actual needs arise
4. Future Ready - Extensible architecture ready for new integrations

Together they create 🌈 Rainbow - but this is just the beginning. Every new plugin adds another color to the spectrum of impossible control.

ELIMS: The platform where fire meets water and new things happen. Forever extensible. Militantly impossible.