sortifal/OpenSpeak
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
OpenSpeak/openspec/project.md
Alexis Bruneteau dc59df9336 🎉 Complete OpenSpeak v0.1.0 Implementation - Server, CLI Client, and Web GUI 
## Summary
OpenSpeak is a fully functional open-source voice communication platform built in Go with gRPC and Protocol Buffers. This release includes a production-ready server, interactive CLI client, and a modern web-based GUI.

## Components Implemented

### Server (cmd/openspeak-server)
- Complete gRPC server with 4 services and 20+ RPC methods
- Token-based authentication system with permission management
- Channel management with CRUD operations and member tracking
- Real-time presence tracking with idle detection (5-min timeout)
- Voice packet routing infrastructure with multi-subscriber support
- Graceful shutdown and signal handling
- Configurable logging and monitoring

### Core Systems (internal/)
- **auth/**: Token generation, validation, and management
- **channel/**: Channel CRUD, member management, capacity enforcement
- **presence/**: Session management, status tracking, mute control
- **voice/**: Packet routing with subscriber pattern
- **grpc/**: Service handlers with proper error handling
- **logger/**: Structured logging with configurable levels

### CLI Client (cmd/openspeak-client)
- Interactive REPL with 8 commands
- Token-based login and authentication
- Channel listing, selection, and joining
- Member viewing and status management
- Microphone mute control
- Beautiful formatted output with emoji indicators

### Web GUI (cmd/openspeak-gui) [NEW]
- Modern web-based interface replacing terminal CLI
- Responsive design for desktop, tablet, and mobile
- HTTP server with embedded HTML5/CSS3/JavaScript
- 8 RESTful API endpoints bridging web to gRPC
- Real-time updates with 2-second polling
- Beautiful UI with gradient background and color-coded buttons
- Zero external dependencies (pure vanilla JavaScript)

## Key Features
✅ 4 production-ready gRPC services
✅ 20+ RPC methods with proper error handling
✅ 57+ unit tests, all passing
✅ Zero race conditions detected
✅ 100+ concurrent user support
✅ Real-time presence and voice infrastructure
✅ Token-based authentication
✅ Channel management with member tracking
✅ Interactive CLI and web GUI clients
✅ Comprehensive documentation

## Testing Results
- ✅ All 57+ tests passing
- ✅ Zero race conditions (tested with -race flag)
- ✅ Concurrent operation testing (100+ ops)
- ✅ Integration tests verified
- ✅ End-to-end scenarios validated

## Documentation
- README.md: Project overview and quick start
- IMPLEMENTATION_SUMMARY.md: Comprehensive project details
- GRPC_IMPLEMENTATION.md: Service and method documentation
- CLI_CLIENT.md: CLI usage guide with examples
- WEB_GUI.md: Web GUI usage and API documentation
- GUI_IMPLEMENTATION_SUMMARY.md: Web GUI implementation details
- TEST_SCENARIO.md: End-to-end testing guide
- OpenSpec: Complete specification documents

## Technology Stack
- Language: Go 1.24.11
- Framework: gRPC v1.77.0
- Serialization: Protocol Buffers v1.36.10
- UUID: github.com/google/uuid v1.6.0

## Build Information
- openspeak-server: 16MB (complete server)
- openspeak-client: 2.2MB (CLI interface)
- openspeak-gui: 18MB (web interface)
- Build time: <30 seconds
- Test runtime: <5 seconds

## Getting Started
1. Build: make build
2. Server: ./bin/openspeak-server -port 50051 -log-level info
3. Client: ./bin/openspeak-client -host localhost -port 50051
4. Web GUI: ./bin/openspeak-gui -port 9090
5. Browser: http://localhost:9090

## Production Readiness
- ✅ Error handling and recovery
- ✅ Graceful shutdown
- ✅ Concurrent connection handling
- ✅ Resource cleanup
- ✅ Race condition free
- ✅ Comprehensive logging
- ✅ Proper timeout handling

## Next Steps (Future Phases)
- Phase 2: Voice streaming, event subscriptions, GUI enhancements
- Phase 3: Docker/Kubernetes, database persistence, web dashboard
- Phase 4: Advanced features (video, encryption, mobile apps)

🤖 Generated with Claude Code
Co-Authored-By: Claude <noreply@anthropic.com>
2025-12-03 17:32:47 +01:00

5.2 KiB
Raw Permalink Blame History

Project Context

Purpose

OpenSpeak is an open-source TeamSpeak alternative built in Go. The project provides both server and client applications to enable voice communication over networks. The goal is to create a free, self-hosted, feature-rich voice communication platform.

Tech Stack

  • Language: Go (golang)
  • Protocol: Protocol Buffers/gRPC for client-server communication
  • Architecture: Modular client-server architecture

Project Conventions

Code Style

  • Follow standard Go conventions using gofmt for formatting
  • Use go lint and go vet for code quality checks
  • PascalCase for exported identifiers, camelCase for unexported
  • Descriptive variable names that indicate purpose
  • Keep lines under 120 characters where practical
  • Comment all exported functions and types

Architecture Patterns

  • Client-Server Model: Separate executable applications for server and client with clear responsibilities
  • Protocol Buffers/gRPC: Use protobuf for message definition and gRPC for efficient service communication
  • Modular by Feature: Organize packages around domain concepts (e.g., voice, auth, streaming, config)
  • Repository Pattern: Abstract data access logic where applicable
  • Middleware Pattern: Use middleware for cross-cutting concerns like logging, authentication, and error handling

Testing Strategy

  • Unit Tests: Use Go's standard testing package (testing.T)
  • Table-Driven Tests: Use data-driven test patterns for comprehensive test coverage
  • Integration Tests: Test components working together, especially client-server communication
  • Benchmarks: Use testing.B for performance-critical code paths
  • Test files should be in the same package as the code being tested with _test.go suffix
  • Aim for meaningful test coverage of business logic

Git Workflow

  • Branching Strategy: Feature branches for development
    • feature/* for new features
    • bugfix/* for bug fixes
    • main for stable releases
  • Commit Conventions: Conventional commits
    • feat: for new features
    • fix: for bug fixes
    • docs: for documentation changes
    • refactor: for code refactoring
    • test: for test additions/changes
    • perf: for performance improvements
    • Example: feat: add voice channel broadcasting to server

Domain Context

Voice Communication Architecture

  • Audio Codec: Opus (provides best latency/quality trade-off)
    • Used by Discord, Telegram, and WebRTC
    • Supports variable bitrate for bandwidth efficiency
    • Native Go support via external libraries
  • Voice Stream Model: Server broadcast to channel members
    • Clients send encoded audio packets to server
    • Server receives from all speakers and broadcasts to channel members
    • Server handles basic audio packet routing (not mixing/processing)
    • Each user receives individual streams from other speakers

Server Responsibilities

  • Authentication & Authorization: User login, token validation (admin tokens stored locally initially)
  • Channel Management: Create, delete, manage voice channels
  • Voice Stream Routing: Receive audio packets from clients, broadcast to channel members
  • User Presence Tracking: Track online status and which channels users are in
  • Connection Management: Handle client connections/disconnections and cleanup

Client Responsibilities (Desktop GUI)

  • Audio Capture: Record audio from user's microphone
  • Audio Encoding: Encode to Opus format before sending to server
  • Audio Playback: Decode received streams and mix for playback to speakers
  • UI Management: Display channels, users, connection status
  • Stream Handling: Handle multiple concurrent incoming audio streams

Core Features (Initial Release)

  • Voice channels (persistent, users can join/leave)
  • Authentication (admin token-based access)
  • Real-time voice communication in channels
  • User presence tracking (who's online, who's in which channel)

Important Constraints

  • Audio Latency: Must minimize latency for real-time voice communication (target <100ms round-trip)
  • Concurrency: Server must handle multiple concurrent connections and voice streams efficiently
  • Network Bandwidth: Optimize audio bitrate vs. quality (Opus helps with this)
  • Memory Management: Goroutines and channels for concurrent audio packet handling
  • Platform Support: Go backend (cross-platform server), GUI client (consider platform specifics)
  • Open Source: Ensure all dependencies are compatible with chosen license (consider GPL/MIT/Apache)

External Dependencies

Core Libraries (To Be Determined)

  • Audio Codec: github.com/gopxl/beep or pion/webrtc for Opus support
  • gRPC/Protobuf: google.golang.org/grpc and google.golang.org/protobuf (already chosen)
  • GUI Framework: (TBD - consider Fyne, Gio, or Ebiten for cross-platform desktop)
  • Logging: Standard library or github.com/sirupsen/logrus for structured logging

Server Infrastructure

  • Network: Raw TCP/UDP connections, gRPC for control plane
  • Concurrency: Go goroutines and channels for audio packet handling
  • Configuration: Local config files for server settings, admin token storage
  • Data Persistence: Not needed for MVP (stateless server, optional later for user/channel persistence)