feat: Electron desktop app

[takhir-iota]

Summary

• Adds Electron desktop app as an alternative to the Bubble Tea TUI
• New Go WebSocket server (cmd/warroom-server) wraps the existing debate.Runner event loop and exposes state + actions over WebSocket
• Electron frontend (electron/) renders the same 3-column dashboard (models roster, activity feed, stats) with web technologies
• Existing CLI is untouched — both TUI and Electron work in parallel

Architecture

Electron main process
  └─ spawns warroom-server binary (auto-assigned port)
      └─ WebSocket server on 127.0.0.1:PORT
          └─ wraps debate.Runner (same engine as TUI)
              └─ same OpenRouter API, session I/O, presets

Electron renderer
  └─ connects to ws://127.0.0.1:PORT/ws
  └─ renders state snapshots as HTML/CSS
  └─ sends user input (topic, API key, ask_user answers) back

New files

File	Purpose
cmd/warroom-server/main.go	Go WebSocket server wrapping debate.Runner
electron/main.js	Electron main process (spawns server, creates window)
electron/preload.js	Context bridge for IPC
electron/renderer.html	App shell
electron/renderer.css	Styles (dark theme matching TUI colors)
electron/renderer.js	Frontend logic (WebSocket, rendering, event handling)
electron/package.json	Electron dependencies and build config

Usage

just build-server   # Build the Go WebSocket server
just electron       # Run Electron app in dev mode
just electron-build # Build distributable DMG

Test plan

• Go server compiles cleanly
• Existing CLI compiles cleanly
• All existing tests pass
• Manual test: just electron launches the app
• Manual test: debate runs end-to-end in Electron

🤖 Generated with Claude Code

Summary by CodeRabbit

Release Notes

• New Features

  • Launched Electron desktop application providing a real-time interactive interface for the War Room debate flow.
  • Implemented WebSocket-based backend server enabling live state updates, model status tracking, activity feeds, and interactive user prompts for API configuration and discussion questions.

• Chores

  • Updated build system to support Electron application bundling and deployment.

[coderabbitai]

Walkthrough

These changes introduce an Electron-based desktop client for the Warroom application, paired with a new WebSocket-based Go server. The Go server manages debate state, handles LLM interactions, and streams state updates to clients. The Electron app provides a real-time dashboard UI with model roster, activity feed, and statistics. Build infrastructure and dependencies are updated to support the new components.

Changes

Cohort / File(s)	Summary
Configuration & Dependencies .gitignore, go.mod	Updated ignore patterns for Electron artifacts and warroom-server binary; added explicit golang.org/x/net dependency and bumped indirect module versions.
Build Infrastructure Justfile	Added four new recipes (build-server, electron-deps, electron, electron-build) for compiling and packaging the server and Electron app; extended clean recipe to remove new build artifacts.
Go WebSocket Server cmd/warroom-server/main.go	Introduces a full WebSocket-based debate runner backend with typed message protocol, state snapshots, discovery/discussion flow helpers, HTTP server setup, and handlers for initialization, action dispatch, LLM execution, and state emission. ~662 lines of server logic.
Electron Desktop App electron/main.js, electron/preload.js, electron/package.json	Electron bootstrap with app lifecycle management, Go server process spawning and port detection, IPC bridge for server port exposure, and package metadata with build targets and resource bundling.
Electron Renderer UI electron/renderer.html, electron/renderer.css, electron/renderer.js	HTML template, comprehensive dark-themed stylesheet with 3-column layout (roster/activity/stats), and vanilla JS renderer implementing WebSocket client, state management, multi-view UI (connect/start/key/topic/dashboard screens), and interactive ask-user overlay for discovery questions.

Sequence Diagram(s)

sequenceDiagram
    participant R as Renderer (JS)
    participant EM as Electron Main
    participant GS as Go Server
    participant WS as WebSocket
    
    EM->>GS: Spawn server process
    GS->>EM: stdout: port number
    EM->>EM: Port received, store
    EM->>R: App ready, window created
    R->>EM: getServerPort() via IPC
    EM-->>R: Return port
    R->>WS: WebSocket connect to localhost:port/ws
    WS->>GS: Connection established
    GS->>WS: Send "hello" with models/presets
    WS->>R: Receive hello message
    R->>R: Render start screen
    R->>WS: Send "set_api_key" message
    WS->>GS: Process API key
    GS->>WS: Send state snapshot
    WS->>R: Receive state update
    R->>R: Render dashboard
    R->>WS: Send "set_topic" message
    WS->>GS: Initialize debate runner
    GS->>GS: Execute round logic
    GS->>WS: Send state updates
    WS->>R: Stream activity/model status
    R->>R: Real-time dashboard refresh

Loading

Estimated Code Review Effort

🎯 4 (Complex) | ⏱️ ~50 minutes

---

🐰 With Electron's gleam and WebSocket's call,
A desktop app for one and all,
Where models debate and state flows free,
Colors dancing, chat in spree,
The warroom's new home comes to be! 🎉

---

Note

🎁 Summarized by CodeRabbit Free

Your organization is on the Free plan. CodeRabbit will generate a high-level summary and a walkthrough for each pull request. For a comprehensive line-by-line review, please upgrade your subscription to CodeRabbit Pro by visiting https://app.coderabbit.ai/login.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}