tony/CHORUS
1
0
Fork 0
Code Issues 10 Pull Requests Actions Packages Projects Releases Wiki Activity

Integrate BACKBEAT SDK and resolve KACHING license validation

Browse Source 
Major integrations and fixes:
- Added BACKBEAT SDK integration for P2P operation timing
- Implemented beat-aware status tracking for distributed operations
- Added Docker secrets support for secure license management
- Resolved KACHING license validation via HTTPS/TLS
- Updated docker-compose configuration for clean stack deployment
- Disabled rollback policies to prevent deployment failures
- Added license credential storage (CHORUS-DEV-MULTI-001)

Technical improvements:
- BACKBEAT P2P operation tracking with phase management
- Enhanced configuration system with file-based secrets
- Improved error handling for license validation
- Clean separation of KACHING and CHORUS deployment stacks

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
anthonyrawlins
2025-09-06 07:56:26 +10:00
parent 543ab216f9
commit 9bdcbe0447
4730 changed files with 1480093 additions and 1916 deletions
Download Patch File Download Diff File Expand all files Collapse all files

228
HAP_ACTION_PLAN.md Normal file
View File

@@ -0,0 +1,228 @@
# CHORUS Human Agent Portal (HAP) — Implementation Action Plan
**Goal:**
Transform the existing CHORUS autonomous agent system into a dual-binary architecture supporting both autonomous agents and human agent portals using shared P2P infrastructure.
---
## 🔍 Current State Analysis
### ✅ What We Have
CHORUS currently implements a **comprehensive P2P autonomous agent system** with:
- **P2P Infrastructure**: libp2p mesh with mDNS discovery
- **Agent Identity**: Crypto-based agent records (`pkg/agentid/`)
- **Messaging**: HMMM collaborative reasoning integration
- **Storage**: DHT with role-based Age encryption
- **Addressing**: UCXL context resolution system (`pkg/ucxl/`)
- **Coordination**: SLURP task distribution (`pkg/slurp/`)
- **Configuration**: Role-based agent definitions
- **Web Interface**: Setup and configuration UI
### ⚠️ What's Missing
- **Multi-binary architecture** (currently single `main.go`)
- **Human interface layer** for message composition and interaction
- **HAP-specific workflows** (templated forms, prompts, context browsing)
---
## 📋 Implementation Phases
### Phase 1: Structural Reorganization (HIGH PRIORITY)
**Goal**: Split monolithic binary into shared runtime + dual binaries
#### Tasks:
- [ ] **1.1** Create `cmd/agent/main.go` (move existing `main.go`)
- [ ] **1.2** Create `cmd/hap/main.go` (new human portal entry point)
- [ ] **1.3** Extract shared initialization to `internal/common/runtime/`
- [ ] **1.4** Update `Makefile` to build both `CHORUS-agent` and `CHORUS-hap` binaries
- [ ] **1.5** Test autonomous agent functionality remains identical
**Key Changes:**
```
/cmd/
/agent/main.go # Existing autonomous agent logic
/hap/main.go # New human agent portal
/internal/common/
/runtime/ # Shared P2P, config, services initialization
agent.go
config.go
services.go
```
**Success Criteria:**
- Both binaries compile successfully
- `CHORUS-agent` maintains all current functionality
- `CHORUS-hap` can join P2P mesh as peer
### Phase 2: HAP Interface Implementation (MEDIUM PRIORITY)
**Goal**: Create human-friendly interaction layer
#### Tasks:
- [ ] **2.1** Implement basic terminal interface in `internal/hapui/terminal.go`
- [ ] **2.2** Create message composition templates for HMMM messages
- [ ] **2.3** Add context browsing interface for UCXL addresses
- [ ] **2.4** Implement justification prompts and metadata helpers
- [ ] **2.5** Test human agent can send/receive HMMM messages
**Key Components:**
```
/internal/hapui/
forms.go # Templated message composition
terminal.go # Terminal-based human interface
context.go # UCXL context browsing helpers
prompts.go # Justification and metadata prompts
```
**Success Criteria:**
- Human can compose and send HMMM messages via terminal
- Context browsing works for UCXL addresses
- HAP appears as valid agent to autonomous peers
### Phase 3: Enhanced Human Workflows (MEDIUM PRIORITY)
**Goal**: Add sophisticated human agent features
#### Tasks:
- [ ] **3.1** Implement patch creation and submission workflows
- [ ] **3.2** Add time-travel diff support (`~~`, `^^` operators)
- [ ] **3.3** Create collaborative editing interfaces
- [ ] **3.4** Add decision tracking and approval workflows
- [ ] **3.5** Implement web bridge for browser-based HAP interface
**Advanced Features:**
- Patch preview before submission to DHT
- Approval chains for architectural decisions
- Real-time collaboration on UCXL contexts
- WebSocket bridge to web UI for rich interface
**Success Criteria:**
- Humans can create and submit patches via HAP
- Approval workflows integrate with existing SLURP coordination
- Web interface provides richer interaction than terminal
### Phase 4: Integration & Optimization (LOW PRIORITY)
**Goal**: Polish and optimize the dual-agent system
#### Tasks:
- [ ] **4.1** Enhance `AgentID` structure to match HAP plan specification
- [ ] **4.2** Optimize resource usage for dual-binary deployment
- [ ] **4.3** Add comprehensive testing for human/machine agent interactions
- [ ] **4.4** Document HAP usage patterns and workflows
- [ ] **4.5** Create deployment guides for mixed agent teams
**Refinements:**
- Performance optimization for shared P2P layer
- Memory usage optimization when running both binaries
- Enhanced logging and monitoring for human activities
- Integration with existing health monitoring system
---
## 🧱 Architecture Alignment
### Current vs Planned Structure
| Component | Current Status | HAP Plan Status | Action Required |
|-----------|----------------|-----------------|-----------------|
| **Multi-binary** | ❌ Single `main.go` | Required | **Phase 1** restructure |
| **Agent Identity** | ✅ `pkg/agentid/` | ✅ Compatible | Minor enhancement |
| **HMMM Messages** | ✅ Integrated | ✅ Complete | None |
| **UCXL Context** | ✅ Full implementation | ✅ Complete | None |
| **DHT Storage** | ✅ Encrypted, distributed | ✅ Complete | None |
| **PubSub Comms** | ✅ Role-based topics | ✅ Complete | None |
| **HAP Interface** | ❌ Not implemented | Required | **Phase 2-3** |
### Shared Runtime Components
Both `bzzz-agent` and `bzzz-hap` will share:
- **P2P networking** and peer discovery
- **Agent identity** and cryptographic signing
- **HMMM message** validation and routing
- **UCXL address** resolution and context storage
- **DHT operations** for distributed state
- **Configuration system** and role definitions
**Only the execution loop and UI modality differ between binaries.**
---
## 🔧 Implementation Strategy
### Incremental Migration Approach
1. **Preserve existing functionality** - autonomous agents continue working
2. **Add HAP alongside** existing system rather than replacing
3. **Test continuously** - both binaries must interoperate correctly
4. **Gradual enhancement** - start with basic HAP, add features incrementally
### Key Principles
- **Backward compatibility**: Existing BZZZ deployments unaffected
- **Shared protocols**: Human and machine agents are indistinguishable on P2P mesh
- **Common codebase**: Maximum code reuse between binaries
- **Incremental delivery**: Each phase delivers working functionality
### Risk Mitigation
- **Comprehensive testing** after each phase
- **Feature flags** to enable/disable HAP features during development
- **Rollback capability** to single binary if needed
- **Documentation** of breaking changes and migration steps
---
## 📈 Success Metrics
### Phase 1 Success
- [ ] `make build` produces both `bzzz-agent` and `bzzz-hap` binaries
- [ ] Existing autonomous agent functionality unchanged
- [ ] Both binaries can join same P2P mesh
### Phase 2 Success
- [ ] Human can send HMMM messages via HAP terminal interface
- [ ] HAP appears as valid agent to autonomous peers
- [ ] Message composition templates functional
### Phase 3 Success
- [ ] Patch submission workflows complete
- [ ] Web interface provides rich HAP experience
- [ ] Human/machine agent collaboration demonstrated
### Overall Success
- [ ] Mixed teams of human and autonomous agents collaborate seamlessly
- [ ] HAP provides superior human experience compared to direct protocol interaction
- [ ] System maintains all existing performance and reliability characteristics
---
## 🎯 Next Steps
### Immediate Actions (This Sprint)
1. **Create cmd/ structure** and move main.go to cmd/agent/
2. **Stub cmd/hap/main.go** with basic P2P initialization
3. **Extract common runtime** to internal/common/
4. **Update Makefile** for dual binary builds
5. **Test agent binary** maintains existing functionality
### Short Term (Next 2-4 weeks)
1. **Implement basic HAP terminal interface**
2. **Add HMMM message composition**
3. **Test human agent P2P participation**
4. **Document HAP usage patterns**
### Medium Term (1-2 months)
1. **Add web bridge for browser interface**
2. **Implement patch workflows**
3. **Add collaborative features**
4. **Optimize performance**
---
## 📚 Resources & References
- **Original HAP Plan**: `archive/bzzz_hap_dev_plan.md`
- **Current Architecture**: `pkg/` directory structure
- **P2P Infrastructure**: `p2p/`, `pubsub/`, `pkg/dht/`
- **Agent Identity**: `pkg/agentid/`, `pkg/crypto/`
- **Messaging**: `pkg/hmmm_adapter/`, HMMM integration
- **Context System**: `pkg/ucxl/`, `pkg/ucxi/`
- **Configuration**: `pkg/config/`, role definitions
The current BZZZ implementation provides an excellent foundation for the HAP vision. The primary challenge is architectural restructuring rather than building new functionality from scratch.

6
README.md
View File

@@ -1,6 +1,6 @@
# CHORUS - Container-First P2P Task Coordination System # CHORUS - Container-First P2P Task Coordination System
CHORUS is a next-generation P2P task coordination and collaborative AI system designed from the ground up for containerized deployments. It takes the best lessons learned from BZZZ and reimagines them for Docker Swarm, Kubernetes, and modern container orchestration platforms. CHORUS is a next-generation P2P task coordination and collaborative AI system designed from the ground up for containerized deployments. It takes the best lessons learned from CHORUS and reimagines them for Docker Swarm, Kubernetes, and modern container orchestration platforms.
## Vision ## Vision
@@ -73,9 +73,9 @@ CHORUS_LICENSE_EMAIL=your-email@example.com
**No license = No operation.** CHORUS will not start without valid licensing. **No license = No operation.** CHORUS will not start without valid licensing.
## Differences from BZZZ ## Differences from CHORUS
| Aspect | BZZZ | CHORUS | | Aspect | CHORUS | CHORUS |
|--------|------|--------| |--------|------|--------|
| Deployment | systemd service (1 per host) | Container (N per cluster) | | Deployment | systemd service (1 per host) | Container (N per cluster) |
| Configuration | Web UI setup | Environment variables | | Configuration | Web UI setup | Environment variables |

4
api/http_server.go
View File

@@ -7,8 +7,8 @@ import (
"strconv" "strconv"
"time" "time"
"chorus.services/bzzz/logging" "chorus/internal/logging"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
"github.com/gorilla/mux" "github.com/gorilla/mux"
) )

224
api/setup_manager.go
View File

@@ -16,12 +16,12 @@ import (
"time" "time"
"golang.org/x/crypto/ssh" "golang.org/x/crypto/ssh"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/security" "chorus/pkg/security"
"chorus.services/bzzz/repository" "chorus/pkg/repository"
) )
// SetupManager handles the initial configuration setup for BZZZ // SetupManager handles the initial configuration setup for CHORUS
type SetupManager struct { type SetupManager struct {
configPath string configPath string
factory repository.ProviderFactory factory repository.ProviderFactory
@@ -514,11 +514,11 @@ func (s *SetupManager) testRepositoryConnection(repoConfig *RepositoryConfig) er
AccessToken: repoConfig.AccessToken, AccessToken: repoConfig.AccessToken,
Owner: repoConfig.Owner, Owner: repoConfig.Owner,
Repository: repoConfig.Repository, Repository: repoConfig.Repository,
TaskLabel: "bzzz-task", TaskLabel: "CHORUS-task",
InProgressLabel: "in-progress", InProgressLabel: "in-progress",
CompletedLabel: "completed", CompletedLabel: "completed",
BaseBranch: "main", BaseBranch: "main",
BranchPrefix: "bzzz/", BranchPrefix: "CHORUS/",
} }
provider, err := s.factory.CreateProvider(ctx, config) provider, err := s.factory.CreateProvider(ctx, config)
@@ -527,7 +527,7 @@ func (s *SetupManager) testRepositoryConnection(repoConfig *RepositoryConfig) er
} }
// Try to list tasks to test connection // Try to list tasks to test connection
_, err = provider.ListAvailableTasks() _, err = provider.ListAvailableTasks(1) // Use project ID 1 for testing
if err != nil { if err != nil {
return fmt.Errorf("failed to connect to repository: %w", err) return fmt.Errorf("failed to connect to repository: %w", err)
} }
@@ -873,7 +873,7 @@ type DeploymentStep struct {
Verified bool `json:"verified"` Verified bool `json:"verified"`
} }
// DeployServiceToMachine deploys BZZZ service to a remote machine with full verification // DeployServiceToMachine deploys CHORUS service to a remote machine with full verification
func (s *SetupManager) DeployServiceToMachine(ip string, privateKey string, username string, password string, port int, config interface{}) (*DeploymentResult, error) { func (s *SetupManager) DeployServiceToMachine(ip string, privateKey string, username string, password string, port int, config interface{}) (*DeploymentResult, error) {
result := &DeploymentResult{ result := &DeploymentResult{
Steps: []DeploymentStep{}, Steps: []DeploymentStep{},
@@ -1137,8 +1137,8 @@ func (s *SetupManager) verifiedPreDeploymentCheck(client *ssh.Client, config int
// Store system info for other steps to use // Store system info for other steps to use
result.SystemInfo = sysInfo result.SystemInfo = sysInfo
// Check for existing BZZZ processes (informational only - cleanup step will handle) // Check for existing CHORUS processes (informational only - cleanup step will handle)
output, err := s.executeSSHCommand(client, "ps aux | grep bzzz | grep -v grep || echo 'No BZZZ processes found'") output, err := s.executeSSHCommand(client, "ps aux | grep CHORUS | grep -v grep || echo 'No CHORUS processes found'")
if err != nil { if err != nil {
s.updateLastStep(result, "failed", "process check", output, fmt.Sprintf("Failed to check processes: %v", err), false) s.updateLastStep(result, "failed", "process check", output, fmt.Sprintf("Failed to check processes: %v", err), false)
return fmt.Errorf("pre-deployment check failed: %v", err) return fmt.Errorf("pre-deployment check failed: %v", err)
@@ -1146,14 +1146,14 @@ func (s *SetupManager) verifiedPreDeploymentCheck(client *ssh.Client, config int
// Log existing processes but don't fail - cleanup step will handle this // Log existing processes but don't fail - cleanup step will handle this
var processStatus string var processStatus string
if !strings.Contains(output, "No BZZZ processes found") { if !strings.Contains(output, "No CHORUS processes found") {
processStatus = "Existing BZZZ processes detected (will be stopped in cleanup step)" processStatus = "Existing CHORUS processes detected (will be stopped in cleanup step)"
} else { } else {
processStatus = "No existing BZZZ processes detected" processStatus = "No existing CHORUS processes detected"
} }
// Check for existing systemd services // Check for existing systemd services
output2, _ := s.executeSSHCommand(client, "systemctl status bzzz 2>/dev/null || echo 'No BZZZ service'") output2, _ := s.executeSSHCommand(client, "systemctl status CHORUS 2>/dev/null || echo 'No CHORUS service'")
// Check system requirements // Check system requirements
output3, _ := s.executeSSHCommand(client, "uname -a && free -m && df -h /tmp") output3, _ := s.executeSSHCommand(client, "uname -a && free -m && df -h /tmp")
@@ -1163,29 +1163,29 @@ func (s *SetupManager) verifiedPreDeploymentCheck(client *ssh.Client, config int
return nil return nil
} }
// verifiedStopExistingServices stops any existing BZZZ services // verifiedStopExistingServices stops any existing CHORUS services
func (s *SetupManager) verifiedStopExistingServices(client *ssh.Client, config interface{}, password string, result *DeploymentResult) error { func (s *SetupManager) verifiedStopExistingServices(client *ssh.Client, config interface{}, password string, result *DeploymentResult) error {
stepName := "Stop & Remove Existing Services" stepName := "Stop & Remove Existing Services"
s.addStep(result, stepName, "running", "", "", "", false) s.addStep(result, stepName, "running", "", "", "", false)
// Stop systemd service if exists // Stop systemd service if exists
cmd1 := "systemctl stop bzzz 2>/dev/null || echo 'No systemd service to stop'" cmd1 := "systemctl stop CHORUS 2>/dev/null || echo 'No systemd service to stop'"
output1, _ := s.executeSudoCommand(client, password, cmd1) output1, _ := s.executeSudoCommand(client, password, cmd1)
// Disable systemd service if exists - separate command for better error tracking // Disable systemd service if exists - separate command for better error tracking
cmd2a := "systemctl disable bzzz 2>/dev/null || echo 'No systemd service to disable'" cmd2a := "systemctl disable CHORUS 2>/dev/null || echo 'No systemd service to disable'"
output2a, _ := s.executeSudoCommand(client, password, cmd2a) output2a, _ := s.executeSudoCommand(client, password, cmd2a)
// Remove service files // Remove service files
cmd2b := "rm -f /etc/systemd/system/bzzz.service ~/.config/systemd/user/bzzz.service 2>/dev/null || echo 'No service file to remove'" cmd2b := "rm -f /etc/systemd/system/CHORUS.service ~/.config/systemd/user/CHORUS.service 2>/dev/null || echo 'No service file to remove'"
output2b, _ := s.executeSudoCommand(client, password, cmd2b) output2b, _ := s.executeSudoCommand(client, password, cmd2b)
// Kill any remaining processes // Kill any remaining processes
cmd3 := "pkill -f bzzz || echo 'No processes to kill'" cmd3 := "pkill -f CHORUS || echo 'No processes to kill'"
output3, _ := s.executeSSHCommand(client, cmd3) output3, _ := s.executeSSHCommand(client, cmd3)
// Remove old binaries from standard locations // Remove old binaries from standard locations
cmd4 := "rm -f /usr/local/bin/bzzz ~/bin/bzzz ~/bzzz 2>/dev/null || echo 'No old binaries to remove'" cmd4 := "rm -f /usr/local/bin/CHORUS ~/bin/CHORUS ~/CHORUS 2>/dev/null || echo 'No old binaries to remove'"
output4, _ := s.executeSudoCommand(client, password, cmd4) output4, _ := s.executeSudoCommand(client, password, cmd4)
// Reload systemd after changes // Reload systemd after changes
@@ -1193,7 +1193,7 @@ func (s *SetupManager) verifiedStopExistingServices(client *ssh.Client, config i
output5, _ := s.executeSudoCommand(client, password, cmd5) output5, _ := s.executeSudoCommand(client, password, cmd5)
// Verify no processes remain // Verify no processes remain
output6, err := s.executeSSHCommand(client, "ps aux | grep bzzz | grep -v grep || echo 'All BZZZ processes stopped'") output6, err := s.executeSSHCommand(client, "ps aux | grep CHORUS | grep -v grep || echo 'All CHORUS processes stopped'")
if err != nil { if err != nil {
combinedOutput := fmt.Sprintf("Stop service:\n%s\n\nDisable service:\n%s\n\nRemove service files:\n%s\n\nKill processes:\n%s\n\nRemove binaries:\n%s\n\nReload systemd:\n%s\n\nVerification:\n%s", combinedOutput := fmt.Sprintf("Stop service:\n%s\n\nDisable service:\n%s\n\nRemove service files:\n%s\n\nKill processes:\n%s\n\nRemove binaries:\n%s\n\nReload systemd:\n%s\n\nVerification:\n%s",
output1, output2a, output2b, output3, output4, output5, output6) output1, output2a, output2b, output3, output4, output5, output6)
@@ -1201,11 +1201,11 @@ func (s *SetupManager) verifiedStopExistingServices(client *ssh.Client, config i
return fmt.Errorf("failed to verify process cleanup: %v", err) return fmt.Errorf("failed to verify process cleanup: %v", err)
} }
if !strings.Contains(output6, "All BZZZ processes stopped") { if !strings.Contains(output6, "All CHORUS processes stopped") {
combinedOutput := fmt.Sprintf("Stop service:\n%s\n\nDisable service:\n%s\n\nRemove service files:\n%s\n\nKill processes:\n%s\n\nRemove binaries:\n%s\n\nReload systemd:\n%s\n\nVerification:\n%s", combinedOutput := fmt.Sprintf("Stop service:\n%s\n\nDisable service:\n%s\n\nRemove service files:\n%s\n\nKill processes:\n%s\n\nRemove binaries:\n%s\n\nReload systemd:\n%s\n\nVerification:\n%s",
output1, output2a, output2b, output3, output4, output5, output6) output1, output2a, output2b, output3, output4, output5, output6)
s.updateLastStep(result, "failed", "process verification", combinedOutput, "BZZZ processes still running after cleanup", false) s.updateLastStep(result, "failed", "process verification", combinedOutput, "CHORUS processes still running after cleanup", false)
return fmt.Errorf("failed to stop all BZZZ processes") return fmt.Errorf("failed to stop all CHORUS processes")
} }
combinedOutput := fmt.Sprintf("Stop service:\n%s\n\nDisable service:\n%s\n\nRemove service files:\n%s\n\nKill processes:\n%s\n\nRemove binaries:\n%s\n\nReload systemd:\n%s\n\nVerification:\n%s", combinedOutput := fmt.Sprintf("Stop service:\n%s\n\nDisable service:\n%s\n\nRemove service files:\n%s\n\nKill processes:\n%s\n\nRemove binaries:\n%s\n\nReload systemd:\n%s\n\nVerification:\n%s",
@@ -1237,17 +1237,17 @@ func (s *SetupManager) performRollbackWithPassword(client *ssh.Client, password
result.RollbackLog = append(result.RollbackLog, "Starting rollback procedure...") result.RollbackLog = append(result.RollbackLog, "Starting rollback procedure...")
// Stop any services we might have started // Stop any services we might have started
if output, err := s.executeSudoCommand(client, password, "systemctl stop bzzz 2>/dev/null || echo 'No service to stop'"); err == nil { if output, err := s.executeSudoCommand(client, password, "systemctl stop CHORUS 2>/dev/null || echo 'No service to stop'"); err == nil {
result.RollbackLog = append(result.RollbackLog, "Stopped service: "+output) result.RollbackLog = append(result.RollbackLog, "Stopped service: "+output)
} }
// Remove systemd service // Remove systemd service
if output, err := s.executeSudoCommand(client, password, "systemctl disable bzzz 2>/dev/null; rm -f /etc/systemd/system/bzzz.service 2>/dev/null || echo 'No service file to remove'"); err == nil { if output, err := s.executeSudoCommand(client, password, "systemctl disable CHORUS 2>/dev/null; rm -f /etc/systemd/system/CHORUS.service 2>/dev/null || echo 'No service file to remove'"); err == nil {
result.RollbackLog = append(result.RollbackLog, "Removed service: "+output) result.RollbackLog = append(result.RollbackLog, "Removed service: "+output)
} }
// Remove binary // Remove binary
if output, err := s.executeSudoCommand(client, password, "rm -f /usr/local/bin/bzzz 2>/dev/null || echo 'No binary to remove'"); err == nil { if output, err := s.executeSudoCommand(client, password, "rm -f /usr/local/bin/CHORUS 2>/dev/null || echo 'No binary to remove'"); err == nil {
result.RollbackLog = append(result.RollbackLog, "Removed binary: "+output) result.RollbackLog = append(result.RollbackLog, "Removed binary: "+output)
} }
@@ -1262,19 +1262,19 @@ func (s *SetupManager) performRollback(client *ssh.Client, result *DeploymentRes
result.RollbackLog = append(result.RollbackLog, "Starting rollback procedure...") result.RollbackLog = append(result.RollbackLog, "Starting rollback procedure...")
// Stop any services we might have started // Stop any services we might have started
if output, err := s.executeSSHCommand(client, "sudo -n systemctl stop bzzz 2>/dev/null || echo 'No service to stop'"); err == nil { if output, err := s.executeSSHCommand(client, "sudo -n systemctl stop CHORUS 2>/dev/null || echo 'No service to stop'"); err == nil {
result.RollbackLog = append(result.RollbackLog, "Stopped service: "+output) result.RollbackLog = append(result.RollbackLog, "Stopped service: "+output)
} }
// Remove binaries we might have copied // Remove binaries we might have copied
if output, err := s.executeSSHCommand(client, "rm -f ~/bzzz /usr/local/bin/bzzz 2>/dev/null || echo 'No binaries to remove'"); err == nil { if output, err := s.executeSSHCommand(client, "rm -f ~/CHORUS /usr/local/bin/CHORUS 2>/dev/null || echo 'No binaries to remove'"); err == nil {
result.RollbackLog = append(result.RollbackLog, "Removed binaries: "+output) result.RollbackLog = append(result.RollbackLog, "Removed binaries: "+output)
} }
result.RollbackLog = append(result.RollbackLog, "Rollback completed") result.RollbackLog = append(result.RollbackLog, "Rollback completed")
} }
// verifiedCopyBinary copies BZZZ binary and verifies installation // verifiedCopyBinary copies CHORUS binary and verifies installation
func (s *SetupManager) verifiedCopyBinary(client *ssh.Client, config interface{}, password string, result *DeploymentResult) error { func (s *SetupManager) verifiedCopyBinary(client *ssh.Client, config interface{}, password string, result *DeploymentResult) error {
stepName := "Copy Binary" stepName := "Copy Binary"
s.addStep(result, stepName, "running", "", "", "", false) s.addStep(result, stepName, "running", "", "", "", false)
@@ -1286,15 +1286,15 @@ func (s *SetupManager) verifiedCopyBinary(client *ssh.Client, config interface{}
} }
// Verify binary was copied and is executable // Verify binary was copied and is executable
checkCmd := "ls -la /usr/local/bin/bzzz ~/bin/bzzz 2>/dev/null || echo 'Binary not found in expected locations'" checkCmd := "ls -la /usr/local/bin/CHORUS ~/bin/CHORUS 2>/dev/null || echo 'Binary not found in expected locations'"
output, err := s.executeSSHCommand(client, checkCmd) output, err := s.executeSSHCommand(client, checkCmd)
if err != nil { if err != nil {
s.updateLastStep(result, "failed", checkCmd, output, fmt.Sprintf("Verification failed: %v", err), false) s.updateLastStep(result, "failed", checkCmd, output, fmt.Sprintf("Verification failed: %v", err), false)
return fmt.Errorf("binary verification failed: %v", err) return fmt.Errorf("binary verification failed: %v", err)
} }
// Verify binary can execute (note: BZZZ doesn't have --version flag, use --help) // Verify binary can execute (note: CHORUS doesn't have --version flag, use --help)
versionCmd := "timeout 3s /usr/local/bin/bzzz --help 2>&1 | head -n1 || timeout 3s ~/bin/bzzz --help 2>&1 | head -n1 || echo 'Binary not executable'" versionCmd := "timeout 3s /usr/local/bin/CHORUS --help 2>&1 | head -n1 || timeout 3s ~/bin/CHORUS --help 2>&1 | head -n1 || echo 'Binary not executable'"
versionOutput, _ := s.executeSSHCommand(client, versionCmd) versionOutput, _ := s.executeSSHCommand(client, versionCmd)
combinedOutput := fmt.Sprintf("File check:\n%s\n\nBinary test:\n%s", output, versionOutput) combinedOutput := fmt.Sprintf("File check:\n%s\n\nBinary test:\n%s", output, versionOutput)
@@ -1320,7 +1320,7 @@ func (s *SetupManager) verifiedDeployConfiguration(client *ssh.Client, config in
} }
// Verify configuration file was created and is valid YAML // Verify configuration file was created and is valid YAML
verifyCmd := "ls -la ~/.bzzz/config.yaml && echo '--- Config Preview ---' && head -20 ~/.bzzz/config.yaml" verifyCmd := "ls -la ~/.CHORUS/config.yaml && echo '--- Config Preview ---' && head -20 ~/.CHORUS/config.yaml"
output, err := s.executeSSHCommand(client, verifyCmd) output, err := s.executeSSHCommand(client, verifyCmd)
if err != nil { if err != nil {
s.updateLastStep(result, "failed", verifyCmd, output, fmt.Sprintf("Config verification failed: %v", err), false) s.updateLastStep(result, "failed", verifyCmd, output, fmt.Sprintf("Config verification failed: %v", err), false)
@@ -1368,11 +1368,11 @@ func (s *SetupManager) verifiedCreateSystemdService(client *ssh.Client, config i
} }
// Verify service file was created and contains correct paths // Verify service file was created and contains correct paths
verifyCmd := "systemctl cat bzzz" verifyCmd := "systemctl cat CHORUS"
output, err := s.executeSudoCommand(client, password, verifyCmd) output, err := s.executeSudoCommand(client, password, verifyCmd)
if err != nil { if err != nil {
// Try to check if the service file exists another way // Try to check if the service file exists another way
checkCmd := "ls -la /etc/systemd/system/bzzz.service" checkCmd := "ls -la /etc/systemd/system/CHORUS.service"
checkOutput, checkErr := s.executeSudoCommand(client, password, checkCmd) checkOutput, checkErr := s.executeSudoCommand(client, password, checkCmd)
if checkErr != nil { if checkErr != nil {
s.updateLastStep(result, "failed", verifyCmd, output, fmt.Sprintf("Service verification failed: %v. Service file check also failed: %v", err, checkErr), false) s.updateLastStep(result, "failed", verifyCmd, output, fmt.Sprintf("Service verification failed: %v. Service file check also failed: %v", err, checkErr), false)
@@ -1382,7 +1382,7 @@ func (s *SetupManager) verifiedCreateSystemdService(client *ssh.Client, config i
} }
// Verify service can be enabled // Verify service can be enabled
enableCmd := "systemctl enable bzzz" enableCmd := "systemctl enable CHORUS"
enableOutput, enableErr := s.executeSudoCommand(client, password, enableCmd) enableOutput, enableErr := s.executeSudoCommand(client, password, enableCmd)
if enableErr != nil { if enableErr != nil {
combinedOutput := fmt.Sprintf("Service file:\n%s\n\nEnable attempt:\n%s", output, enableOutput) combinedOutput := fmt.Sprintf("Service file:\n%s\n\nEnable attempt:\n%s", output, enableOutput)
@@ -1411,25 +1411,25 @@ func (s *SetupManager) verifiedStartService(client *ssh.Client, config interface
s.addStep(result, "Pre-Start Checks", "running", "", "", "", false) s.addStep(result, "Pre-Start Checks", "running", "", "", "", false)
// Check if config file exists and is readable by the service user // Check if config file exists and is readable by the service user
configCheck := "ls -la /home/*/bzzz/config.yaml 2>/dev/null || echo 'Config file not found'" configCheck := "ls -la /home/*/CHORUS/config.yaml 2>/dev/null || echo 'Config file not found'"
configOutput, _ := s.executeSSHCommand(client, configCheck) configOutput, _ := s.executeSSHCommand(client, configCheck)
// Check if binary is executable // Check if binary is executable
binCheck := "ls -la /usr/local/bin/bzzz" binCheck := "ls -la /usr/local/bin/CHORUS"
binOutput, _ := s.executeSudoCommand(client, password, binCheck) binOutput, _ := s.executeSudoCommand(client, password, binCheck)
preflightInfo := fmt.Sprintf("Binary check:\n%s\n\nConfig check:\n%s", binOutput, configOutput) preflightInfo := fmt.Sprintf("Binary check:\n%s\n\nConfig check:\n%s", binOutput, configOutput)
s.updateLastStep(result, "success", "pre-flight", preflightInfo, "Pre-start checks completed", false) s.updateLastStep(result, "success", "pre-flight", preflightInfo, "Pre-start checks completed", false)
// Start the service // Start the service
startCmd := "systemctl start bzzz" startCmd := "systemctl start CHORUS"
startOutput, err := s.executeSudoCommand(client, password, startCmd) startOutput, err := s.executeSudoCommand(client, password, startCmd)
if err != nil { if err != nil {
// Get detailed error information // Get detailed error information
statusCmd := "systemctl status bzzz" statusCmd := "systemctl status CHORUS"
statusOutput, _ := s.executeSudoCommand(client, password, statusCmd) statusOutput, _ := s.executeSudoCommand(client, password, statusCmd)
logsCmd := "journalctl -u bzzz --no-pager -n 20" logsCmd := "journalctl -u CHORUS --no-pager -n 20"
logsOutput, _ := s.executeSudoCommand(client, password, logsCmd) logsOutput, _ := s.executeSudoCommand(client, password, logsCmd)
// Combine all error information // Combine all error information
@@ -1440,21 +1440,21 @@ func (s *SetupManager) verifiedStartService(client *ssh.Client, config interface
return fmt.Errorf("failed to start systemd service: %v", err) return fmt.Errorf("failed to start systemd service: %v", err)
} }
// Wait for service to fully initialize (BZZZ needs time to start all subsystems) // Wait for service to fully initialize (CHORUS needs time to start all subsystems)
time.Sleep(8 * time.Second) time.Sleep(8 * time.Second)
// Verify service is running // Verify service is running
statusCmd := "systemctl status bzzz" statusCmd := "systemctl status CHORUS"
statusOutput, _ := s.executeSSHCommand(client, statusCmd) statusOutput, _ := s.executeSSHCommand(client, statusCmd)
// Check if service is active // Check if service is active
if !strings.Contains(statusOutput, "active (running)") { if !strings.Contains(statusOutput, "active (running)") {
// Get detailed logs to understand why service failed // Get detailed logs to understand why service failed
logsCmd := "journalctl -u bzzz --no-pager -n 20" logsCmd := "journalctl -u CHORUS --no-pager -n 20"
logsOutput, _ := s.executeSudoCommand(client, password, logsCmd) logsOutput, _ := s.executeSudoCommand(client, password, logsCmd)
// Check if config file exists and is readable // Check if config file exists and is readable
configCheckCmd := "ls -la ~/.bzzz/config.yaml && head -5 ~/.bzzz/config.yaml" configCheckCmd := "ls -la ~/.CHORUS/config.yaml && head -5 ~/.CHORUS/config.yaml"
configCheckOutput, _ := s.executeSSHCommand(client, configCheckCmd) configCheckOutput, _ := s.executeSSHCommand(client, configCheckCmd)
combinedOutput := fmt.Sprintf("Start attempt:\n%s\n\nStatus check:\n%s\n\nRecent logs:\n%s\n\nConfig check:\n%s", combinedOutput := fmt.Sprintf("Start attempt:\n%s\n\nStatus check:\n%s\n\nRecent logs:\n%s\n\nConfig check:\n%s",
@@ -1474,12 +1474,12 @@ func (s *SetupManager) verifiedPostDeploymentTest(client *ssh.Client, config int
s.addStep(result, stepName, "running", "", "", "", false) s.addStep(result, stepName, "running", "", "", "", false)
// Test 1: Verify binary is executable // Test 1: Verify binary is executable
// Note: BZZZ binary doesn't have --version flag, so just check if it's executable and can start help // Note: CHORUS binary doesn't have --version flag, so just check if it's executable and can start help
versionCmd := "if pgrep -f bzzz >/dev/null; then echo 'BZZZ process running'; else timeout 3s /usr/local/bin/bzzz --help 2>&1 | head -n1 || timeout 3s ~/bin/bzzz --help 2>&1 | head -n1 || echo 'Binary not executable'; fi" versionCmd := "if pgrep -f CHORUS >/dev/null; then echo 'CHORUS process running'; else timeout 3s /usr/local/bin/CHORUS --help 2>&1 | head -n1 || timeout 3s ~/bin/CHORUS --help 2>&1 | head -n1 || echo 'Binary not executable'; fi"
versionOutput, _ := s.executeSSHCommand(client, versionCmd) versionOutput, _ := s.executeSSHCommand(client, versionCmd)
// Test 2: Verify service status // Test 2: Verify service status
serviceCmd := "systemctl status bzzz --no-pager" serviceCmd := "systemctl status CHORUS --no-pager"
serviceOutput, _ := s.executeSSHCommand(client, serviceCmd) serviceOutput, _ := s.executeSSHCommand(client, serviceCmd)
// Test 3: Wait for API to be ready, then check if setup API is responding // Test 3: Wait for API to be ready, then check if setup API is responding
@@ -1503,15 +1503,15 @@ func (s *SetupManager) verifiedPostDeploymentTest(client *ssh.Client, config int
} }
// Test 4: Verify configuration is readable // Test 4: Verify configuration is readable
configCmd := "test -r ~/.bzzz/config.yaml && echo 'Config readable' || echo 'Config not readable'" configCmd := "test -r ~/.CHORUS/config.yaml && echo 'Config readable' || echo 'Config not readable'"
configOutput, _ := s.executeSSHCommand(client, configCmd) configOutput, _ := s.executeSSHCommand(client, configCmd)
combinedOutput := fmt.Sprintf("Binary test:\n%s\n\nService test:\n%s\n\nAPI test:\n%s\n\nConfig test:\n%s", combinedOutput := fmt.Sprintf("Binary test:\n%s\n\nService test:\n%s\n\nAPI test:\n%s\n\nConfig test:\n%s",
versionOutput, serviceOutput, apiOutput, configOutput) versionOutput, serviceOutput, apiOutput, configOutput)
// Determine if tests passed and provide detailed failure information // Determine if tests passed and provide detailed failure information
// Binary test passes if BZZZ is running OR if help command succeeded // Binary test passes if CHORUS is running OR if help command succeeded
binaryFailed := strings.Contains(versionOutput, "Binary not executable") && !strings.Contains(versionOutput, "BZZZ process running") binaryFailed := strings.Contains(versionOutput, "Binary not executable") && !strings.Contains(versionOutput, "CHORUS process running")
configFailed := strings.Contains(configOutput, "Config not readable") configFailed := strings.Contains(configOutput, "Config not readable")
if binaryFailed || configFailed { if binaryFailed || configFailed {
@@ -1532,7 +1532,7 @@ func (s *SetupManager) verifiedPostDeploymentTest(client *ssh.Client, config int
return nil return nil
} }
// copyBinaryToMachineWithPassword copies the BZZZ binary to remote machine using SCP protocol with sudo password // copyBinaryToMachineWithPassword copies the CHORUS binary to remote machine using SCP protocol with sudo password
func (s *SetupManager) copyBinaryToMachineWithPassword(client *ssh.Client, password string) error { func (s *SetupManager) copyBinaryToMachineWithPassword(client *ssh.Client, password string) error {
// Read current binary // Read current binary
binaryPath, err := os.Executable() binaryPath, err := os.Executable()
@@ -1567,12 +1567,12 @@ func (s *SetupManager) copyBinaryToMachineWithPassword(client *ssh.Client, passw
} }
// Start SCP receive command on remote host // Start SCP receive command on remote host
remotePath := "~/bzzz" remotePath := "~/CHORUS"
go func() { go func() {
defer stdin.Close() defer stdin.Close()
// Send SCP header: C<mode> <size> <filename>\n // Send SCP header: C<mode> <size> <filename>\n
header := fmt.Sprintf("C0755 %d bzzz\n", len(binaryData)) header := fmt.Sprintf("C0755 %d CHORUS\n", len(binaryData))
stdin.Write([]byte(header)) stdin.Write([]byte(header))
// Wait for acknowledgment // Wait for acknowledgment
@@ -1602,7 +1602,7 @@ func (s *SetupManager) copyBinaryToMachineWithPassword(client *ssh.Client, passw
} }
defer session.Close() defer session.Close()
if err := session.Run("chmod +x ~/bzzz"); err != nil { if err := session.Run("chmod +x ~/CHORUS"); err != nil {
return fmt.Errorf("failed to make binary executable: %w", err) return fmt.Errorf("failed to make binary executable: %w", err)
} }
@@ -1617,11 +1617,11 @@ func (s *SetupManager) copyBinaryToMachineWithPassword(client *ssh.Client, passw
var sudoCmd string var sudoCmd string
if password == "" { if password == "" {
// Try passwordless sudo first // Try passwordless sudo first
sudoCmd = "sudo -n mv ~/bzzz /usr/local/bin/bzzz && sudo -n chmod +x /usr/local/bin/bzzz" sudoCmd = "sudo -n mv ~/CHORUS /usr/local/bin/CHORUS && sudo -n chmod +x /usr/local/bin/CHORUS"
} else { } else {
// Use password sudo // Use password sudo
escapedPassword := strings.ReplaceAll(password, "'", "'\"'\"'") escapedPassword := strings.ReplaceAll(password, "'", "'\"'\"'")
sudoCmd = fmt.Sprintf("echo '%s' | sudo -S mv ~/bzzz /usr/local/bin/bzzz && echo '%s' | sudo -S chmod +x /usr/local/bin/bzzz", sudoCmd = fmt.Sprintf("echo '%s' | sudo -S mv ~/CHORUS /usr/local/bin/CHORUS && echo '%s' | sudo -S chmod +x /usr/local/bin/CHORUS",
escapedPassword, escapedPassword) escapedPassword, escapedPassword)
} }
@@ -1634,7 +1634,7 @@ func (s *SetupManager) copyBinaryToMachineWithPassword(client *ssh.Client, passw
defer session.Close() defer session.Close()
// Create ~/bin directory and add to PATH if it doesn't exist // Create ~/bin directory and add to PATH if it doesn't exist
if err := session.Run("mkdir -p ~/bin && mv ~/bzzz ~/bin/bzzz && chmod +x ~/bin/bzzz"); err != nil { if err := session.Run("mkdir -p ~/bin && mv ~/CHORUS ~/bin/CHORUS && chmod +x ~/bin/CHORUS"); err != nil {
return fmt.Errorf("failed to install binary to ~/bin: %w", err) return fmt.Errorf("failed to install binary to ~/bin: %w", err)
} }
@@ -1651,7 +1651,7 @@ func (s *SetupManager) copyBinaryToMachineWithPassword(client *ssh.Client, passw
return nil return nil
} }
// copyBinaryToMachine copies the BZZZ binary to remote machine using SCP protocol (passwordless sudo) // copyBinaryToMachine copies the CHORUS binary to remote machine using SCP protocol (passwordless sudo)
func (s *SetupManager) copyBinaryToMachine(client *ssh.Client) error { func (s *SetupManager) copyBinaryToMachine(client *ssh.Client) error {
return s.copyBinaryToMachineWithPassword(client, "") return s.copyBinaryToMachineWithPassword(client, "")
} }
@@ -1669,8 +1669,8 @@ func (s *SetupManager) createSystemdServiceWithPassword(client *ssh.Client, conf
session.Stdout = &stdout session.Stdout = &stdout
// Check where the binary was installed // Check where the binary was installed
binaryPath := "/usr/local/bin/bzzz" binaryPath := "/usr/local/bin/CHORUS"
if err := session.Run("test -f /usr/local/bin/bzzz"); err != nil { if err := session.Run("test -f /usr/local/bin/CHORUS"); err != nil {
// If not in /usr/local/bin, it should be in ~/bin // If not in /usr/local/bin, it should be in ~/bin
session, err = client.NewSession() session, err = client.NewSession()
if err != nil { if err != nil {
@@ -1679,7 +1679,7 @@ func (s *SetupManager) createSystemdServiceWithPassword(client *ssh.Client, conf
defer session.Close() defer session.Close()
session.Stdout = &stdout session.Stdout = &stdout
if err := session.Run("echo $HOME/bin/bzzz"); err == nil { if err := session.Run("echo $HOME/bin/CHORUS"); err == nil {
binaryPath = strings.TrimSpace(stdout.String()) binaryPath = strings.TrimSpace(stdout.String())
} }
} }
@@ -1700,13 +1700,13 @@ func (s *SetupManager) createSystemdServiceWithPassword(client *ssh.Client, conf
// Create service file with actual username // Create service file with actual username
serviceFile := fmt.Sprintf(`[Unit] serviceFile := fmt.Sprintf(`[Unit]
Description=BZZZ P2P Task Coordination System Description=CHORUS P2P Task Coordination System
Documentation=https://chorus.services/docs/bzzz Documentation=https://chorus.services/docs/CHORUS
After=network.target After=network.target
[Service] [Service]
Type=simple Type=simple
ExecStart=%s --config /home/%s/.bzzz/config.yaml ExecStart=%s --config /home/%s/.CHORUS/config.yaml
Restart=always Restart=always
RestartSec=10 RestartSec=10
User=%s User=%s
@@ -1717,13 +1717,13 @@ WantedBy=multi-user.target
`, binaryPath, username, username, username) `, binaryPath, username, username, username)
// Create service file in temp location first, then move with sudo // Create service file in temp location first, then move with sudo
createCmd := fmt.Sprintf("cat > /tmp/bzzz.service << 'EOF'\n%sEOF", serviceFile) createCmd := fmt.Sprintf("cat > /tmp/CHORUS.service << 'EOF'\n%sEOF", serviceFile)
if _, err := s.executeSSHCommand(client, createCmd); err != nil { if _, err := s.executeSSHCommand(client, createCmd); err != nil {
return fmt.Errorf("failed to create temp service file: %w", err) return fmt.Errorf("failed to create temp service file: %w", err)
} }
// Move to systemd directory using password sudo // Move to systemd directory using password sudo
moveCmd := "mv /tmp/bzzz.service /etc/systemd/system/bzzz.service" moveCmd := "mv /tmp/CHORUS.service /etc/systemd/system/CHORUS.service"
if _, err := s.executeSudoCommand(client, password, moveCmd); err != nil { if _, err := s.executeSudoCommand(client, password, moveCmd); err != nil {
return fmt.Errorf("failed to install system service file: %w", err) return fmt.Errorf("failed to install system service file: %w", err)
} }
@@ -1750,8 +1750,8 @@ func (s *SetupManager) createSystemdService(client *ssh.Client, config interface
session.Stdout = &stdout session.Stdout = &stdout
// Check where the binary was installed // Check where the binary was installed
binaryPath := "/usr/local/bin/bzzz" binaryPath := "/usr/local/bin/CHORUS"
if err := session.Run("test -f /usr/local/bin/bzzz"); err != nil { if err := session.Run("test -f /usr/local/bin/CHORUS"); err != nil {
// If not in /usr/local/bin, it should be in ~/bin // If not in /usr/local/bin, it should be in ~/bin
session, err = client.NewSession() session, err = client.NewSession()
if err != nil { if err != nil {
@@ -1760,20 +1760,20 @@ func (s *SetupManager) createSystemdService(client *ssh.Client, config interface
defer session.Close() defer session.Close()
session.Stdout = &stdout session.Stdout = &stdout
if err := session.Run("echo $HOME/bin/bzzz"); err == nil { if err := session.Run("echo $HOME/bin/CHORUS"); err == nil {
binaryPath = strings.TrimSpace(stdout.String()) binaryPath = strings.TrimSpace(stdout.String())
} }
} }
// Create service file that works for both system and user services // Create service file that works for both system and user services
serviceFile := fmt.Sprintf(`[Unit] serviceFile := fmt.Sprintf(`[Unit]
Description=BZZZ P2P Task Coordination System Description=CHORUS P2P Task Coordination System
Documentation=https://chorus.services/docs/bzzz Documentation=https://chorus.services/docs/CHORUS
After=network.target After=network.target
[Service] [Service]
Type=simple Type=simple
ExecStart=%s --config %%h/.bzzz/config.yaml ExecStart=%s --config %%h/.CHORUS/config.yaml
Restart=always Restart=always
RestartSec=10 RestartSec=10
Environment=HOME=%%h Environment=HOME=%%h
@@ -1790,7 +1790,7 @@ WantedBy=default.target
defer session.Close() defer session.Close()
// Create service file in temp location first, then move with sudo // Create service file in temp location first, then move with sudo
cmd := fmt.Sprintf("cat > /tmp/bzzz.service << 'EOF'\n%sEOF", serviceFile) cmd := fmt.Sprintf("cat > /tmp/CHORUS.service << 'EOF'\n%sEOF", serviceFile)
if err := session.Run(cmd); err != nil { if err := session.Run(cmd); err != nil {
return fmt.Errorf("failed to create temp service file: %w", err) return fmt.Errorf("failed to create temp service file: %w", err)
} }
@@ -1803,7 +1803,7 @@ WantedBy=default.target
defer session.Close() defer session.Close()
// Try passwordless sudo for system service // Try passwordless sudo for system service
if err := session.Run("sudo -n mv /tmp/bzzz.service /etc/systemd/system/bzzz.service"); err != nil { if err := session.Run("sudo -n mv /tmp/CHORUS.service /etc/systemd/system/CHORUS.service"); err != nil {
// Sudo failed, create user-level service instead // Sudo failed, create user-level service instead
session, err = client.NewSession() session, err = client.NewSession()
if err != nil { if err != nil {
@@ -1812,7 +1812,7 @@ WantedBy=default.target
defer session.Close() defer session.Close()
// Create user systemd directory and install service there // Create user systemd directory and install service there
if err := session.Run("mkdir -p ~/.config/systemd/user && mv /tmp/bzzz.service ~/.config/systemd/user/bzzz.service"); err != nil { if err := session.Run("mkdir -p ~/.config/systemd/user && mv /tmp/CHORUS.service ~/.config/systemd/user/CHORUS.service"); err != nil {
return fmt.Errorf("failed to install user service file: %w", err) return fmt.Errorf("failed to install user service file: %w", err)
} }
@@ -1823,8 +1823,8 @@ WantedBy=default.target
} }
defer session.Close() defer session.Close()
if err := session.Run("systemctl --user daemon-reload && systemctl --user enable bzzz"); err != nil { if err := session.Run("systemctl --user daemon-reload && systemctl --user enable CHORUS"); err != nil {
return fmt.Errorf("failed to enable user bzzz service: %w", err) return fmt.Errorf("failed to enable user CHORUS service: %w", err)
} }
// Enable lingering so user services start at boot // Enable lingering so user services start at boot
@@ -1844,8 +1844,8 @@ WantedBy=default.target
} }
defer session.Close() defer session.Close()
if err := session.Run("sudo -n useradd -r -s /bin/false bzzz 2>/dev/null || true"); err != nil { if err := session.Run("sudo -n useradd -r -s /bin/false CHORUS 2>/dev/null || true"); err != nil {
return fmt.Errorf("failed to create bzzz user: %w", err) return fmt.Errorf("failed to create CHORUS user: %w", err)
} }
session, err = client.NewSession() session, err = client.NewSession()
@@ -1854,8 +1854,8 @@ WantedBy=default.target
} }
defer session.Close() defer session.Close()
if err := session.Run("sudo -n mkdir -p /opt/bzzz && sudo -n chown bzzz:bzzz /opt/bzzz"); err != nil { if err := session.Run("sudo -n mkdir -p /opt/CHORUS && sudo -n chown CHORUS:CHORUS /opt/CHORUS"); err != nil {
return fmt.Errorf("failed to create bzzz directory: %w", err) return fmt.Errorf("failed to create CHORUS directory: %w", err)
} }
// Reload systemd and enable service // Reload systemd and enable service
@@ -1865,15 +1865,15 @@ WantedBy=default.target
} }
defer session.Close() defer session.Close()
if err := session.Run("sudo -n systemctl daemon-reload && sudo -n systemctl enable bzzz"); err != nil { if err := session.Run("sudo -n systemctl daemon-reload && sudo -n systemctl enable CHORUS"); err != nil {
return fmt.Errorf("failed to enable bzzz service: %w", err) return fmt.Errorf("failed to enable CHORUS service: %w", err)
} }
} }
return nil return nil
} }
// startService starts the BZZZ service (system or user level) // startService starts the CHORUS service (system or user level)
func (s *SetupManager) startService(client *ssh.Client) error { func (s *SetupManager) startService(client *ssh.Client) error {
session, err := client.NewSession() session, err := client.NewSession()
if err != nil { if err != nil {
@@ -1882,7 +1882,7 @@ func (s *SetupManager) startService(client *ssh.Client) error {
defer session.Close() defer session.Close()
// Try system service first, fall back to user service // Try system service first, fall back to user service
if err := session.Run("sudo -n systemctl start bzzz"); err != nil { if err := session.Run("sudo -n systemctl start CHORUS"); err != nil {
// Try user service instead // Try user service instead
session, err = client.NewSession() session, err = client.NewSession()
if err != nil { if err != nil {
@@ -1890,7 +1890,7 @@ func (s *SetupManager) startService(client *ssh.Client) error {
} }
defer session.Close() defer session.Close()
return session.Run("systemctl --user start bzzz") return session.Run("systemctl --user start CHORUS")
} }
return nil return nil
@@ -1938,7 +1938,7 @@ func (s *SetupManager) GenerateConfigForMachine(machineIP string, config interfa
} }
// Generate YAML configuration that matches the Go struct layout // Generate YAML configuration that matches the Go struct layout
configYAML := fmt.Sprintf(`# BZZZ Configuration for %s configYAML := fmt.Sprintf(`# CHORUS Configuration for %s
whoosh_api: whoosh_api:
base_url: "https://whoosh.home.deepblack.cloud" base_url: "https://whoosh.home.deepblack.cloud"
timeout: 30s timeout: 30s
@@ -1953,7 +1953,7 @@ agent:
specialization: "general_developer" specialization: "general_developer"
model_selection_webhook: "https://n8n.home.deepblack.cloud/webhook/model-selection" model_selection_webhook: "https://n8n.home.deepblack.cloud/webhook/model-selection"
default_reasoning_model: "phi3" default_reasoning_model: "phi3"
sandbox_image: "registry.home.deepblack.cloud/bzzz-sandbox:latest" sandbox_image: "registry.home.deepblack.cloud/CHORUS-sandbox:latest"
role: "" role: ""
system_prompt: "" system_prompt: ""
reports_to: [] reports_to: []
@@ -1976,8 +1976,8 @@ github:
assignee: "" assignee: ""
p2p: p2p:
service_tag: "bzzz-peer-discovery" service_tag: "CHORUS-peer-discovery"
bzzz_topic: "bzzz/coordination/v1" bzzz_topic: "CHORUS/coordination/v1"
hmmm_topic: "hmmm/meta-discussion/v1" hmmm_topic: "hmmm/meta-discussion/v1"
discovery_timeout: 10s discovery_timeout: 10s
escalation_webhook: "https://n8n.home.deepblack.cloud/webhook-test/human-escalation" escalation_webhook: "https://n8n.home.deepblack.cloud/webhook-test/human-escalation"
@@ -2011,7 +2011,7 @@ v2:
enabled: false enabled: false
bootstrap_peers: [] bootstrap_peers: []
mode: "auto" mode: "auto"
protocol_prefix: "/bzzz" protocol_prefix: "/CHORUS"
bootstrap_timeout: 30s bootstrap_timeout: 30s
discovery_interval: 1m0s discovery_interval: 1m0s
auto_bootstrap: false auto_bootstrap: false
@@ -2031,7 +2031,7 @@ ucxl:
enabled: false enabled: false
server: server:
port: 8081 port: 8081
base_path: "/bzzz" base_path: "/CHORUS"
enabled: true enabled: true
resolution: resolution:
cache_ttl: 5m0s cache_ttl: 5m0s
@@ -2039,12 +2039,12 @@ ucxl:
max_results: 50 max_results: 50
storage: storage:
type: "filesystem" type: "filesystem"
directory: "/tmp/bzzz-ucxl-storage" directory: "/tmp/CHORUS-ucxl-storage"
max_size: 104857600 max_size: 104857600
p2p_integration: p2p_integration:
enable_announcement: true enable_announcement: true
enable_discovery: true enable_discovery: true
announcement_topic: "bzzz/ucxl/announcement/v1" announcement_topic: "CHORUS/ucxl/announcement/v1"
discovery_timeout: 30s discovery_timeout: 30s
security: security:
@@ -2063,7 +2063,7 @@ security:
conflict_resolution: "highest_uptime" conflict_resolution: "highest_uptime"
key_rotation_days: 90 key_rotation_days: 90
audit_logging: true audit_logging: true
audit_path: ".bzzz/security-audit.log" audit_path: ".CHORUS/security-audit.log"
ai: ai:
ollama: ollama:
@@ -2079,7 +2079,7 @@ ai:
return configYAML, nil return configYAML, nil
} }
// GenerateConfigForMachineSimple generates a simple BZZZ configuration that matches the working config structure // GenerateConfigForMachineSimple generates a simple CHORUS configuration that matches the working config structure
// REVENUE CRITICAL: This method now properly processes license data to enable revenue protection // REVENUE CRITICAL: This method now properly processes license data to enable revenue protection
func (s *SetupManager) GenerateConfigForMachineSimple(machineIP string, config interface{}) (string, error) { func (s *SetupManager) GenerateConfigForMachineSimple(machineIP string, config interface{}) (string, error) {
// CRITICAL FIX: Extract license data from setup configuration - this was being ignored! // CRITICAL FIX: Extract license data from setup configuration - this was being ignored!
@@ -2103,7 +2103,7 @@ func (s *SetupManager) GenerateConfigForMachineSimple(machineIP string, config i
// Validate license data exists - FAIL CLOSED DESIGN // Validate license data exists - FAIL CLOSED DESIGN
if licenseData == nil { if licenseData == nil {
return "", fmt.Errorf("REVENUE PROTECTION: License data missing from setup configuration - BZZZ cannot be deployed without valid licensing") return "", fmt.Errorf("REVENUE PROTECTION: License data missing from setup configuration - CHORUS cannot be deployed without valid licensing")
} }
// Extract required license fields with validation // Extract required license fields with validation
@@ -2112,14 +2112,14 @@ func (s *SetupManager) GenerateConfigForMachineSimple(machineIP string, config i
orgName, _ := licenseData["organizationName"].(string) orgName, _ := licenseData["organizationName"].(string)
if email == "" || licenseKey == "" { if email == "" || licenseKey == "" {
return "", fmt.Errorf("REVENUE PROTECTION: Email and license key are required - cannot deploy BZZZ without valid licensing") return "", fmt.Errorf("REVENUE PROTECTION: Email and license key are required - cannot deploy CHORUS without valid licensing")
} }
// Generate unique cluster ID for license binding (prevents license sharing across clusters) // Generate unique cluster ID for license binding (prevents license sharing across clusters)
clusterID := fmt.Sprintf("cluster-%s-%d", hostname, time.Now().Unix()) clusterID := fmt.Sprintf("cluster-%s-%d", hostname, time.Now().Unix())
// Generate YAML configuration with FULL license integration for revenue protection // Generate YAML configuration with FULL license integration for revenue protection
configYAML := fmt.Sprintf(`# BZZZ Configuration for %s - REVENUE PROTECTED configYAML := fmt.Sprintf(`# CHORUS Configuration for %s - REVENUE PROTECTED
# Generated at %s with license validation # Generated at %s with license validation
whoosh_api: whoosh_api:
base_url: "https://whoosh.home.deepblack.cloud" base_url: "https://whoosh.home.deepblack.cloud"
@@ -2153,14 +2153,14 @@ agent:
github: github:
token_file: "" token_file: ""
user_agent: "BZZZ-Agent/1.0" user_agent: "CHORUS-Agent/1.0"
timeout: 30s timeout: 30s
rate_limit: true rate_limit: true
assignee: "" assignee: ""
p2p: p2p:
service_tag: "bzzz-peer-discovery" service_tag: "CHORUS-peer-discovery"
bzzz_topic: "bzzz/coordination/v1" bzzz_topic: "CHORUS/coordination/v1"
hmmm_topic: "hmmm/meta-discussion/v1" hmmm_topic: "hmmm/meta-discussion/v1"
discovery_timeout: 10s discovery_timeout: 10s
escalation_webhook: "" escalation_webhook: ""
@@ -2194,7 +2194,7 @@ v2:
enabled: false enabled: false
bootstrap_peers: [] bootstrap_peers: []
mode: "auto" mode: "auto"
protocol_prefix: "/bzzz" protocol_prefix: "/CHORUS"
bootstrap_timeout: 30s bootstrap_timeout: 30s
discovery_interval: 1m0s discovery_interval: 1m0s
auto_bootstrap: false auto_bootstrap: false
@@ -2214,7 +2214,7 @@ ucxl:
enabled: false enabled: false
server: server:
port: 8081 port: 8081
base_path: "/bzzz" base_path: "/CHORUS"
enabled: false enabled: false
resolution: resolution:
cache_ttl: 5m0s cache_ttl: 5m0s
@@ -2222,12 +2222,12 @@ ucxl:
max_results: 50 max_results: 50
storage: storage:
type: "filesystem" type: "filesystem"
directory: "/tmp/bzzz-ucxl-storage" directory: "/tmp/CHORUS-ucxl-storage"
max_size: 104857600 max_size: 104857600
p2p_integration: p2p_integration:
enable_announcement: false enable_announcement: false
enable_discovery: false enable_discovery: false
announcement_topic: "bzzz/ucxl/announcement/v1" announcement_topic: "CHORUS/ucxl/announcement/v1"
discovery_timeout: 30s discovery_timeout: 30s
security: security:
@@ -2308,7 +2308,7 @@ func (s *SetupManager) generateAndDeployConfig(client *ssh.Client, nodeIP string
} }
defer session.Close() defer session.Close()
if err := session.Run("mkdir -p ~/.bzzz ~/.bzzz/data ~/.bzzz/logs"); err != nil { if err := session.Run("mkdir -p ~/.CHORUS ~/.CHORUS/data ~/.CHORUS/logs"); err != nil {
return fmt.Errorf("failed to create config directories: %w", err) return fmt.Errorf("failed to create config directories: %w", err)
} }
@@ -2329,14 +2329,14 @@ func (s *SetupManager) generateAndDeployConfig(client *ssh.Client, nodeIP string
stdin.Write([]byte(configYAML)) stdin.Write([]byte(configYAML))
}() }()
if err := session.Run("cat > ~/.bzzz/config.yaml"); err != nil { if err := session.Run("cat > ~/.CHORUS/config.yaml"); err != nil {
return fmt.Errorf("failed to deploy config file: %w", err) return fmt.Errorf("failed to deploy config file: %w", err)
} }
return nil return nil
} }
// configureFirewall configures firewall rules for BZZZ ports // configureFirewall configures firewall rules for CHORUS ports
func (s *SetupManager) configureFirewall(client *ssh.Client, config interface{}) error { func (s *SetupManager) configureFirewall(client *ssh.Client, config interface{}) error {
// Extract ports from configuration // Extract ports from configuration
configMap, ok := config.(map[string]interface{}) configMap, ok := config.(map[string]interface{})
@@ -2346,7 +2346,7 @@ func (s *SetupManager) configureFirewall(client *ssh.Client, config interface{})
ports := []string{"22"} // Always include SSH ports := []string{"22"} // Always include SSH
// Add BZZZ ports // Add CHORUS ports
if portsConfig, exists := configMap["ports"]; exists { if portsConfig, exists := configMap["ports"]; exists {
if portsMap, ok := portsConfig.(map[string]interface{}); ok { if portsMap, ok := portsConfig.(map[string]interface{}); ok {
for _, value := range portsMap { for _, value := range portsMap {

298
cmd/chorus/main.go
View File

@@ -1,37 +1,30 @@
package main package main
import ( import (
"bytes"
"context" "context"
"encoding/json"
"fmt" "fmt"
"log" "log"
"net/http" "net/http"
"os" "os"
"os/signal"
"path/filepath" "path/filepath"
"reflect"
"runtime"
"syscall"
"time" "time"
"chorus.services/chorus/api" "chorus/api"
"chorus.services/chorus/coordinator" "chorus/coordinator"
"chorus.services/chorus/discovery" "chorus/discovery"
"chorus.services/chorus/internal/licensing" "chorus/internal/backbeat"
"chorus.services/chorus/internal/logging" "chorus/internal/licensing"
"chorus.services/chorus/p2p" "chorus/internal/logging"
"chorus.services/chorus/pkg/config" "chorus/p2p"
"chorus.services/chorus/pkg/crypto" "chorus/pkg/config"
"chorus.services/chorus/pkg/dht" "chorus/pkg/dht"
"chorus.services/chorus/pkg/election" "chorus/pkg/election"
"chorus.services/chorus/pkg/health" "chorus/pkg/health"
"chorus.services/chorus/pkg/shutdown" "chorus/pkg/shutdown"
"chorus.services/chorus/pkg/ucxi" "chorus/pkg/ucxi"
"chorus.services/chorus/pkg/ucxl" "chorus/pkg/ucxl"
"chorus.services/chorus/pkg/version" "chorus/pubsub"
"chorus.services/chorus/pubsub" "chorus/reasoning"
"chorus.services/chorus/reasoning"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
"github.com/multiformats/go-multiaddr" "github.com/multiformats/go-multiaddr"
) )
@@ -41,6 +34,21 @@ const (
AppVersion = "0.1.0-dev" AppVersion = "0.1.0-dev"
) )
// SimpleLogger provides basic logging implementation
type SimpleLogger struct{}
func (l *SimpleLogger) Info(msg string, args ...interface{}) {
log.Printf("[INFO] "+msg, args...)
}
func (l *SimpleLogger) Warn(msg string, args ...interface{}) {
log.Printf("[WARN] "+msg, args...)
}
func (l *SimpleLogger) Error(msg string, args ...interface{}) {
log.Printf("[ERROR] "+msg, args...)
}
// SimpleTaskTracker tracks active tasks for availability reporting // SimpleTaskTracker tracks active tasks for availability reporting
type SimpleTaskTracker struct { type SimpleTaskTracker struct {
maxTasks int maxTasks int
@@ -91,14 +99,42 @@ func (t *SimpleTaskTracker) publishTaskCompletion(taskID string, success bool, s
} }
func main() { func main() {
// Initialize container-optimized logger // Early CLI handling: print help/version without requiring env/config
logger := logging.NewContainerLogger(AppName) for _, a := range os.Args[1:] {
switch a {
case "--help", "-h", "help":
fmt.Printf("%s %s\n\n", AppName, AppVersion)
fmt.Println("Usage:")
fmt.Printf(" %s [--help] [--version]\n\n", filepath.Base(os.Args[0]))
fmt.Println("Environment (common):")
fmt.Println(" CHORUS_LICENSE_ID (required)")
fmt.Println(" CHORUS_AGENT_ID (optional; auto-generated if empty)")
fmt.Println(" CHORUS_P2P_PORT (default 9000)")
fmt.Println(" CHORUS_API_PORT (default 8080)")
fmt.Println(" CHORUS_HEALTH_PORT (default 8081)")
fmt.Println(" CHORUS_DHT_ENABLED (default true)")
fmt.Println(" CHORUS_BOOTSTRAP_PEERS (comma-separated multiaddrs)")
fmt.Println(" OLLAMA_ENDPOINT (default http://localhost:11434)")
fmt.Println()
fmt.Println("Example:")
fmt.Println(" CHORUS_LICENSE_ID=dev-123 \\")
fmt.Println(" CHORUS_AGENT_ID=chorus-dev \\")
fmt.Println(" CHORUS_P2P_PORT=9000 CHORUS_API_PORT=8080 ./chorus")
return
case "--version", "-v":
fmt.Printf("%s %s\n", AppName, AppVersion)
return
}
}
// Initialize container-optimized logger
logger := &SimpleLogger{}
ctx, cancel := context.WithCancel(context.Background()) ctx, cancel := context.WithCancel(context.Background())
defer cancel() defer cancel()
logger.Info("🎭 Starting CHORUS v%s - Container-First P2P Task Coordination", AppVersion) logger.Info("🎭 Starting CHORUS v%s - Container-First P2P Task Coordination", AppVersion)
logger.Info("📦 Container deployment of proven BZZZ functionality") logger.Info("📦 Container deployment of proven CHORUS functionality")
// Load configuration from environment (no config files in containers) // Load configuration from environment (no config files in containers)
logger.Info("📋 Loading configuration from environment variables...") logger.Info("📋 Loading configuration from environment variables...")
@@ -114,7 +150,11 @@ func main() {
// CRITICAL: Validate license before any P2P operations // CRITICAL: Validate license before any P2P operations
logger.Info("🔐 Validating CHORUS license with KACHING...") logger.Info("🔐 Validating CHORUS license with KACHING...")
licenseValidator := licensing.NewValidator(cfg.License) licenseValidator := licensing.NewValidator(licensing.LicenseConfig{
LicenseID: cfg.License.LicenseID,
ClusterID: cfg.License.ClusterID,
KachingURL: cfg.License.KachingURL,
})
if err := licenseValidator.Validate(); err != nil { if err := licenseValidator.Validate(); err != nil {
logger.Error("❌ License validation failed: %v", err) logger.Error("❌ License validation failed: %v", err)
logger.Error("💰 CHORUS requires a valid license to operate") logger.Error("💰 CHORUS requires a valid license to operate")
@@ -123,6 +163,34 @@ func main() {
} }
logger.Info("✅ License validation successful - CHORUS authorized to run") logger.Info("✅ License validation successful - CHORUS authorized to run")
// Initialize AI provider configuration
logger.Info("🧠 Configuring AI provider: %s", cfg.AI.Provider)
if err := initializeAIProvider(cfg, logger); err != nil {
logger.Error("❌ AI provider initialization failed: %v", err)
os.Exit(1)
}
logger.Info("✅ AI provider configured successfully")
// Initialize BACKBEAT integration
var backbeatIntegration *backbeat.Integration
backbeatIntegration, err = backbeat.NewIntegration(cfg, cfg.Agent.ID, logger)
if err != nil {
logger.Warn("⚠️ BACKBEAT integration initialization failed: %v", err)
logger.Info("📍 P2P operations will run without beat synchronization")
} else {
if err := backbeatIntegration.Start(ctx); err != nil {
logger.Warn("⚠️ Failed to start BACKBEAT integration: %v", err)
backbeatIntegration = nil
} else {
logger.Info("🎵 BACKBEAT integration started successfully")
}
}
defer func() {
if backbeatIntegration != nil {
backbeatIntegration.Stop()
}
}()
// Initialize P2P node // Initialize P2P node
node, err := p2p.NewNode(ctx) node, err := p2p.NewNode(ctx)
if err != nil { if err != nil {
@@ -160,7 +228,11 @@ func main() {
// Join role-based topics if role is configured // Join role-based topics if role is configured
if cfg.Agent.Role != "" { if cfg.Agent.Role != "" {
if err := ps.JoinRoleBasedTopics(cfg.Agent.Role, cfg.Agent.Expertise, cfg.Agent.ReportsTo); err != nil { reportsTo := []string{}
if cfg.Agent.ReportsTo != "" {
reportsTo = []string{cfg.Agent.ReportsTo}
}
if err := ps.JoinRoleBasedTopics(cfg.Agent.Role, cfg.Agent.Expertise, reportsTo); err != nil {
logger.Warn("⚠️ Failed to join role-based topics: %v", err) logger.Warn("⚠️ Failed to join role-based topics: %v", err)
} else { } else {
logger.Info("🎯 Joined role-based collaboration topics") logger.Info("🎯 Joined role-based collaboration topics")
@@ -170,11 +242,23 @@ func main() {
// === Admin Election System === // === Admin Election System ===
electionManager := election.NewElectionManager(ctx, cfg, node.Host(), ps, node.ID().ShortString()) electionManager := election.NewElectionManager(ctx, cfg, node.Host(), ps, node.ID().ShortString())
// Set election callbacks // Set election callbacks with BACKBEAT integration
electionManager.SetCallbacks( electionManager.SetCallbacks(
func(oldAdmin, newAdmin string) { func(oldAdmin, newAdmin string) {
logger.Info("👑 Admin changed: %s -> %s", oldAdmin, newAdmin) logger.Info("👑 Admin changed: %s -> %s", oldAdmin, newAdmin)
// Track admin change with BACKBEAT if available
if backbeatIntegration != nil {
operationID := fmt.Sprintf("admin-change-%d", time.Now().Unix())
if err := backbeatIntegration.StartP2POperation(operationID, "admin_change", 2, map[string]interface{}{
"old_admin": oldAdmin,
"new_admin": newAdmin,
}); err == nil {
// Complete immediately as this is a state change, not a long operation
backbeatIntegration.CompleteP2POperation(operationID, 1)
}
}
// If this node becomes admin, enable SLURP functionality // If this node becomes admin, enable SLURP functionality
if newAdmin == node.ID().ShortString() { if newAdmin == node.ID().ShortString() {
logger.Info("🎯 This node is now admin - enabling SLURP functionality") logger.Info("🎯 This node is now admin - enabling SLURP functionality")
@@ -187,6 +271,17 @@ func main() {
}, },
func(winner string) { func(winner string) {
logger.Info("🏆 Election completed, winner: %s", winner) logger.Info("🏆 Election completed, winner: %s", winner)
// Track election completion with BACKBEAT if available
if backbeatIntegration != nil {
operationID := fmt.Sprintf("election-completed-%d", time.Now().Unix())
if err := backbeatIntegration.StartP2POperation(operationID, "election", 1, map[string]interface{}{
"winner": winner,
"node_id": node.ID().ShortString(),
}); err == nil {
backbeatIntegration.CompleteP2POperation(operationID, 1)
}
}
}, },
) )
@@ -210,9 +305,23 @@ func main() {
} else { } else {
logger.Info("🕸️ DHT initialized") logger.Info("🕸️ DHT initialized")
// Bootstrap DHT // Bootstrap DHT with BACKBEAT tracking
if err := dhtNode.Bootstrap(); err != nil { if backbeatIntegration != nil {
logger.Warn("⚠️ DHT bootstrap failed: %v", err) operationID := fmt.Sprintf("dht-bootstrap-%d", time.Now().Unix())
if err := backbeatIntegration.StartP2POperation(operationID, "dht_bootstrap", 4, nil); err == nil {
backbeatIntegration.UpdateP2POperationPhase(operationID, backbeat.PhaseConnecting, 0)
}
if err := dhtNode.Bootstrap(); err != nil {
logger.Warn("⚠️ DHT bootstrap failed: %v", err)
backbeatIntegration.FailP2POperation(operationID, err.Error())
} else {
backbeatIntegration.CompleteP2POperation(operationID, 1)
}
} else {
if err := dhtNode.Bootstrap(); err != nil {
logger.Warn("⚠️ DHT bootstrap failed: %v", err)
}
} }
// Connect to bootstrap peers if configured // Connect to bootstrap peers if configured
@@ -230,10 +339,28 @@ func main() {
continue continue
} }
if err := node.Host().Connect(ctx, *info); err != nil { // Track peer discovery with BACKBEAT if available
logger.Warn("⚠️ Failed to connect to bootstrap peer %s: %v", addrStr, err) if backbeatIntegration != nil {
operationID := fmt.Sprintf("peer-discovery-%d", time.Now().Unix())
if err := backbeatIntegration.StartP2POperation(operationID, "peer_discovery", 2, map[string]interface{}{
"peer_addr": addrStr,
}); err == nil {
backbeatIntegration.UpdateP2POperationPhase(operationID, backbeat.PhaseConnecting, 0)
if err := node.Host().Connect(ctx, *info); err != nil {
logger.Warn("⚠️ Failed to connect to bootstrap peer %s: %v", addrStr, err)
backbeatIntegration.FailP2POperation(operationID, err.Error())
} else {
logger.Info("🔗 Connected to DHT bootstrap peer: %s", addrStr)
backbeatIntegration.CompleteP2POperation(operationID, 1)
}
}
} else { } else {
logger.Info("🔗 Connected to DHT bootstrap peer: %s", addrStr) if err := node.Host().Connect(ctx, *info); err != nil {
logger.Warn("⚠️ Failed to connect to bootstrap peer %s: %v", addrStr, err)
} else {
logger.Info("🔗 Connected to DHT bootstrap peer: %s", addrStr)
}
} }
} }
@@ -364,7 +491,7 @@ func main() {
healthManager.SetShutdownManager(shutdownManager) healthManager.SetShutdownManager(shutdownManager)
// Register health checks // Register health checks
setupHealthChecks(healthManager, ps, node, dhtNode) setupHealthChecks(healthManager, ps, node, dhtNode, backbeatIntegration)
// Register components for graceful shutdown // Register components for graceful shutdown
setupGracefulShutdown(shutdownManager, healthManager, node, ps, mdnsDiscovery, setupGracefulShutdown(shutdownManager, healthManager, node, ps, mdnsDiscovery,
@@ -395,8 +522,8 @@ func main() {
logger.Info("✅ CHORUS system shutdown completed") logger.Info("✅ CHORUS system shutdown completed")
} }
// Rest of the functions (setupHealthChecks, etc.) would be adapted from BZZZ... // Rest of the functions (setupHealthChecks, etc.) would be adapted from CHORUS...
// For brevity, I'll include key functions but the full implementation would port all BZZZ functionality // For brevity, I'll include key functions but the full implementation would port all CHORUS functionality
// simpleLogger implements basic logging for shutdown and health systems // simpleLogger implements basic logging for shutdown and health systems
type simpleLogger struct { type simpleLogger struct {
@@ -458,21 +585,104 @@ func statusReporter(node *p2p.Node, logger logging.Logger) {
} }
} }
// Placeholder functions for full BZZZ port - these would be fully implemented // Placeholder functions for full CHORUS port - these would be fully implemented
func announceCapabilitiesOnChange(ps *pubsub.PubSub, nodeID string, cfg *config.Config, logger logging.Logger) { func announceCapabilitiesOnChange(ps *pubsub.PubSub, nodeID string, cfg *config.Config, logger logging.Logger) {
// Implementation from BZZZ would go here // Implementation from CHORUS would go here
} }
func announceRoleOnStartup(ps *pubsub.PubSub, nodeID string, cfg *config.Config, logger logging.Logger) { func announceRoleOnStartup(ps *pubsub.PubSub, nodeID string, cfg *config.Config, logger logging.Logger) {
// Implementation from BZZZ would go here // Implementation from CHORUS would go here
} }
func setupHealthChecks(healthManager *health.Manager, ps *pubsub.PubSub, node *p2p.Node, dhtNode *dht.LibP2PDHT) { func setupHealthChecks(healthManager *health.Manager, ps *pubsub.PubSub, node *p2p.Node, dhtNode *dht.LibP2PDHT, backbeatIntegration *backbeat.Integration) {
// Implementation from BZZZ would go here // Add BACKBEAT health check
if backbeatIntegration != nil {
backbeatCheck := &health.HealthCheck{
Name: "backbeat",
Description: "BACKBEAT timing integration health",
Interval: 30 * time.Second,
Timeout: 10 * time.Second,
Enabled: true,
Critical: false,
Checker: func(ctx context.Context) health.CheckResult {
healthInfo := backbeatIntegration.GetHealth()
connected, _ := healthInfo["connected"].(bool)
result := health.CheckResult{
Healthy: connected,
Details: healthInfo,
Timestamp: time.Now(),
}
if connected {
result.Message = "BACKBEAT integration healthy and connected"
} else {
result.Message = "BACKBEAT integration not connected"
}
return result
},
}
healthManager.RegisterCheck(backbeatCheck)
}
// Implementation from CHORUS would go here - other health checks
} }
func setupGracefulShutdown(shutdownManager *shutdown.Manager, healthManager *health.Manager, func setupGracefulShutdown(shutdownManager *shutdown.Manager, healthManager *health.Manager,
node *p2p.Node, ps *pubsub.PubSub, mdnsDiscovery interface{}, electionManager interface{}, node *p2p.Node, ps *pubsub.PubSub, mdnsDiscovery interface{}, electionManager interface{},
httpServer *api.HTTPServer, ucxiServer *ucxi.Server, taskCoordinator interface{}, dhtNode *dht.LibP2PDHT) { httpServer *api.HTTPServer, ucxiServer *ucxi.Server, taskCoordinator interface{}, dhtNode *dht.LibP2PDHT) {
// Implementation from BZZZ would go here // Implementation from CHORUS would go here
}
// initializeAIProvider configures the reasoning engine with the appropriate AI provider
func initializeAIProvider(cfg *config.Config, logger logging.Logger) error {
// Set the AI provider
reasoning.SetAIProvider(cfg.AI.Provider)
// Configure the selected provider
switch cfg.AI.Provider {
case "resetdata":
if cfg.AI.ResetData.APIKey == "" {
return fmt.Errorf("RESETDATA_API_KEY environment variable is required for resetdata provider")
}
resetdataConfig := reasoning.ResetDataConfig{
BaseURL: cfg.AI.ResetData.BaseURL,
APIKey: cfg.AI.ResetData.APIKey,
Model: cfg.AI.ResetData.Model,
Timeout: cfg.AI.ResetData.Timeout,
}
reasoning.SetResetDataConfig(resetdataConfig)
logger.Info("🌐 ResetData AI provider configured - Endpoint: %s, Model: %s",
cfg.AI.ResetData.BaseURL, cfg.AI.ResetData.Model)
case "ollama":
reasoning.SetOllamaEndpoint(cfg.AI.Ollama.Endpoint)
logger.Info("🦙 Ollama AI provider configured - Endpoint: %s", cfg.AI.Ollama.Endpoint)
default:
logger.Warn("⚠️ Unknown AI provider '%s', defaulting to resetdata", cfg.AI.Provider)
if cfg.AI.ResetData.APIKey == "" {
return fmt.Errorf("RESETDATA_API_KEY environment variable is required for default resetdata provider")
}
resetdataConfig := reasoning.ResetDataConfig{
BaseURL: cfg.AI.ResetData.BaseURL,
APIKey: cfg.AI.ResetData.APIKey,
Model: cfg.AI.ResetData.Model,
Timeout: cfg.AI.ResetData.Timeout,
}
reasoning.SetResetDataConfig(resetdataConfig)
reasoning.SetAIProvider("resetdata")
}
// Configure model selection
reasoning.SetModelConfig(
cfg.Agent.Models,
cfg.Agent.ModelSelectionWebhook,
cfg.Agent.DefaultReasoningModel,
)
return nil
} }

31
coordinator/task_coordinator.go
View File

@@ -7,11 +7,11 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/logging" "chorus/internal/logging"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
"chorus.services/bzzz/repository" "chorus/pkg/repository"
"chorus.services/hmmm/pkg/hmmm" "chorus/pkg/hmmm"
"github.com/google/uuid" "github.com/google/uuid"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
) )
@@ -88,8 +88,8 @@ func NewTaskCoordinator(
MaxTasks: cfg.Agent.MaxTasks, MaxTasks: cfg.Agent.MaxTasks,
Status: "ready", Status: "ready",
LastSeen: time.Now(), LastSeen: time.Now(),
Performance: 0.8, // Default performance score Performance: map[string]interface{}{"score": 0.8}, // Default performance score
Availability: 1.0, Availability: "available",
} }
return coordinator return coordinator
@@ -148,7 +148,7 @@ func (tc *TaskCoordinator) shouldProcessTask(task *repository.Task) bool {
} }
// Check minimum score threshold // Check minimum score threshold
score := tc.taskMatcher.ScoreTaskForAgent(task, tc.agentInfo.Role, tc.agentInfo.Expertise) score := tc.taskMatcher.ScoreTaskForAgent(task, tc.agentInfo)
return score > 0.5 // Only process tasks with good fit return score > 0.5 // Only process tasks with good fit
} }
@@ -162,15 +162,15 @@ func (tc *TaskCoordinator) processTask(task *repository.Task, provider repositor
} }
// Attempt to claim the task // Attempt to claim the task
claimedTask, err := provider.ClaimTask(task.Number, tc.agentInfo.ID) claimed, err := provider.ClaimTask(task.Number, tc.agentInfo.ID)
if err != nil { if err != nil || !claimed {
fmt.Printf("⚠️ Failed to claim task %s #%d: %v\n", task.Repository, task.Number, err) fmt.Printf("⚠️ Failed to claim task %s #%d: %v\n", task.Repository, task.Number, err)
return false return false
} }
// Create active task // Create active task
activeTask := &ActiveTask{ activeTask := &ActiveTask{
Task: claimedTask, Task: task,
Provider: provider, Provider: provider,
ProjectID: projectID, ProjectID: projectID,
ClaimedAt: time.Now(), ClaimedAt: time.Now(),
@@ -208,7 +208,7 @@ func (tc *TaskCoordinator) processTask(task *repository.Task, provider repositor
NodeID: tc.nodeID, NodeID: tc.nodeID,
HopCount: 0, HopCount: 0,
Timestamp: time.Now().UTC(), Timestamp: time.Now().UTC(),
Message: fmt.Sprintf("Seed: Task '%s' claimed. Description: %s", task.Title, task.Description), Message: fmt.Sprintf("Seed: Task '%s' claimed. Description: %s", task.Title, task.Body),
} }
if err := tc.hmmmRouter.Publish(tc.ctx, seedMsg); err != nil { if err := tc.hmmmRouter.Publish(tc.ctx, seedMsg); err != nil {
fmt.Printf("⚠️ Failed to seed HMMM room for task %d: %v\n", task.Number, err) fmt.Printf("⚠️ Failed to seed HMMM room for task %d: %v\n", task.Number, err)
@@ -308,7 +308,12 @@ func (tc *TaskCoordinator) executeTask(activeTask *ActiveTask) {
"agent_role": tc.agentInfo.Role, "agent_role": tc.agentInfo.Role,
} }
err := activeTask.Provider.CompleteTask(activeTask.Task.Number, tc.agentInfo.ID, results) taskResult := &repository.TaskResult{
Success: true,
Message: "Task completed successfully",
Metadata: results,
}
err := activeTask.Provider.CompleteTask(activeTask.Task, taskResult)
if err != nil { if err != nil {
fmt.Printf("❌ Failed to complete task %s #%d: %v\n", activeTask.Task.Repository, activeTask.Task.Number, err) fmt.Printf("❌ Failed to complete task %s #%d: %v\n", activeTask.Task.Repository, activeTask.Task.Number, err)

2
discovery/mdns.go
View File

@@ -30,7 +30,7 @@ type mdnsNotifee struct {
// NewMDNSDiscovery creates a new mDNS discovery service // NewMDNSDiscovery creates a new mDNS discovery service
func NewMDNSDiscovery(ctx context.Context, h host.Host, serviceTag string) (*MDNSDiscovery, error) { func NewMDNSDiscovery(ctx context.Context, h host.Host, serviceTag string) (*MDNSDiscovery, error) {
if serviceTag == "" { if serviceTag == "" {
serviceTag = "bzzz-peer-discovery" serviceTag = "CHORUS-peer-discovery"
} }
discoveryCtx, cancel := context.WithCancel(ctx) discoveryCtx, cancel := context.WithCancel(ctx)

1
docker/CHORUS_LICENSE_ID Normal file
View File

@@ -0,0 +1 @@
CHORUS-DEV-MULTI-001

9
docker/Dockerfile
View File

@@ -1,7 +1,7 @@
# CHORUS - Container-First P2P Task Coordination System # CHORUS - Container-First P2P Task Coordination System
# Multi-stage build for minimal production image # Multi-stage build for minimal production image
FROM golang:1.21-alpine AS builder FROM golang:1.23-alpine AS builder
# Install build dependencies # Install build dependencies
RUN apk --no-cache add git ca-certificates RUN apk --no-cache add git ca-certificates
@@ -10,13 +10,16 @@ WORKDIR /build
# Copy go mod files first (for better caching) # Copy go mod files first (for better caching)
COPY go.mod go.sum ./ COPY go.mod go.sum ./
RUN go mod download
# Copy vendor directory for local dependencies
COPY vendor/ vendor/
# Copy source code # Copy source code
COPY . . COPY . .
# Build the CHORUS binary # Build the CHORUS binary with vendor mode
RUN CGO_ENABLED=0 GOOS=linux go build \ RUN CGO_ENABLED=0 GOOS=linux go build \
-mod=vendor \
-ldflags='-w -s -extldflags "-static"' \ -ldflags='-w -s -extldflags "-static"' \
-o chorus \ -o chorus \
./cmd/chorus ./cmd/chorus

5
docker/build.sh
View File

@@ -22,9 +22,8 @@ echo "🚀 Quick Start:"
echo " 1. Copy environment file:" echo " 1. Copy environment file:"
echo " cp docker/chorus.env.example docker/chorus.env" echo " cp docker/chorus.env.example docker/chorus.env"
echo "" echo ""
echo " 2. Edit docker/chorus.env with your license key:" echo " 2. Edit docker/chorus.env with your license ID:"
echo " CHORUS_LICENSE_EMAIL=your-email@example.com" echo " CHORUS_LICENSE_ID=your-license-id-here"
echo " CHORUS_LICENSE_KEY=your-license-key-here"
echo "" echo ""
echo " 3. Start CHORUS:" echo " 3. Start CHORUS:"
echo " docker-compose -f docker/docker-compose.yml --env-file docker/chorus.env up -d" echo " docker-compose -f docker/docker-compose.yml --env-file docker/chorus.env up -d"

20
docker/chorus.env.example
View File

@@ -5,9 +5,8 @@
# REQUIRED SETTINGS # REQUIRED SETTINGS
# ================= # =================
# License configuration (REQUIRED - CHORUS will not start without these) # License configuration (REQUIRED - CHORUS will not start without this)
CHORUS_LICENSE_EMAIL=your-email@example.com CHORUS_LICENSE_ID=your-license-id-here
CHORUS_LICENSE_KEY=your-license-key-here
CHORUS_CLUSTER_ID=production-cluster CHORUS_CLUSTER_ID=production-cluster
# ================== # ==================
@@ -25,9 +24,20 @@ CHORUS_API_PORT=8080
CHORUS_HEALTH_PORT=8081 CHORUS_HEALTH_PORT=8081
CHORUS_P2P_PORT=9000 CHORUS_P2P_PORT=9000
# AI Integration # AI Integration - Provider Selection
CHORUS_AI_PROVIDER=resetdata # resetdata (default) or ollama
# ResetData Configuration (default provider)
RESETDATA_BASE_URL=https://models.au-syd.resetdata.ai/v1
RESETDATA_API_KEY= # REQUIRED - Your ResetData API key
RESETDATA_MODEL=meta/llama-3.1-8b-instruct # ResetData model to use
# Ollama Configuration (alternative provider)
OLLAMA_ENDPOINT=http://host.docker.internal:11434 OLLAMA_ENDPOINT=http://host.docker.internal:11434
CHORUS_DEFAULT_MODEL=llama3.1:8b
# Model Configuration (both providers)
CHORUS_MODELS=meta/llama-3.1-8b-instruct # Available models for selection
CHORUS_DEFAULT_REASONING_MODEL=meta/llama-3.1-8b-instruct
# Logging # Logging
LOG_LEVEL=info # debug, info, warn, error LOG_LEVEL=info # debug, info, warn, error

453
docker/docker-compose.yml
View File

@@ -2,17 +2,14 @@ version: "3.9"
services: services:
chorus: chorus:
build: image: anthonyrawlins/chorus:backbeat-v2.0.1
context: ..
dockerfile: docker/Dockerfile
image: chorus:latest
# REQUIRED: License configuration (CHORUS will not start without this) # REQUIRED: License configuration (CHORUS will not start without this)
environment: environment:
# CRITICAL: License configuration - REQUIRED for operation # CRITICAL: License configuration - REQUIRED for operation
- CHORUS_LICENSE_EMAIL=${CHORUS_LICENSE_EMAIL:?CHORUS_LICENSE_EMAIL is required} - CHORUS_LICENSE_ID_FILE=/run/secrets/chorus_license_id
- CHORUS_LICENSE_KEY=${CHORUS_LICENSE_KEY:?CHORUS_LICENSE_KEY is required}
- CHORUS_CLUSTER_ID=${CHORUS_CLUSTER_ID:-docker-cluster} - CHORUS_CLUSTER_ID=${CHORUS_CLUSTER_ID:-docker-cluster}
- CHORUS_KACHING_URL=${CHORUS_KACHING_URL:-https://kaching.chorus.services/api}
# Agent configuration # Agent configuration
- CHORUS_AGENT_ID=${CHORUS_AGENT_ID:-} # Auto-generated if not provided - CHORUS_AGENT_ID=${CHORUS_AGENT_ID:-} # Auto-generated if not provided
@@ -26,22 +23,41 @@ services:
- CHORUS_P2P_PORT=9000 - CHORUS_P2P_PORT=9000
- CHORUS_BIND_ADDRESS=0.0.0.0 - CHORUS_BIND_ADDRESS=0.0.0.0
# AI configuration # AI configuration - Provider selection
- CHORUS_AI_PROVIDER=${CHORUS_AI_PROVIDER:-resetdata}
# ResetData configuration (default provider)
- RESETDATA_BASE_URL=${RESETDATA_BASE_URL:-https://models.au-syd.resetdata.ai/v1}
- RESETDATA_API_KEY=${RESETDATA_API_KEY:?RESETDATA_API_KEY is required for resetdata provider}
- RESETDATA_MODEL=${RESETDATA_MODEL:-meta/llama-3.1-8b-instruct}
# Ollama configuration (alternative provider)
- OLLAMA_ENDPOINT=${OLLAMA_ENDPOINT:-http://host.docker.internal:11434} - OLLAMA_ENDPOINT=${OLLAMA_ENDPOINT:-http://host.docker.internal:11434}
- CHORUS_DEFAULT_MODEL=${CHORUS_DEFAULT_MODEL:-llama3.1:8b}
# Model configuration
- CHORUS_MODELS=${CHORUS_MODELS:-meta/llama-3.1-8b-instruct}
- CHORUS_DEFAULT_REASONING_MODEL=${CHORUS_DEFAULT_REASONING_MODEL:-meta/llama-3.1-8b-instruct}
# Logging configuration # Logging configuration
- LOG_LEVEL=${LOG_LEVEL:-info} - LOG_LEVEL=${LOG_LEVEL:-info}
- LOG_FORMAT=${LOG_FORMAT:-structured} - LOG_FORMAT=${LOG_FORMAT:-structured}
# BACKBEAT configuration
- CHORUS_BACKBEAT_ENABLED=${CHORUS_BACKBEAT_ENABLED:-true}
- CHORUS_BACKBEAT_CLUSTER_ID=${CHORUS_BACKBEAT_CLUSTER_ID:-chorus-production}
- CHORUS_BACKBEAT_AGENT_ID=${CHORUS_BACKBEAT_AGENT_ID:-} # Auto-generated from CHORUS_AGENT_ID
- CHORUS_BACKBEAT_NATS_URL=${CHORUS_BACKBEAT_NATS_URL:-nats://backbeat-nats:4222}
# Docker secrets for sensitive configuration
secrets:
- chorus_license_id
# Persistent data storage # Persistent data storage
volumes: volumes:
- chorus_data:/app/data - chorus_data:/app/data
# Network ports # Network ports
ports: ports:
- "${CHORUS_API_PORT:-8080}:8080" # HTTP API
- "${CHORUS_HEALTH_PORT:-8081}:8081" # Health checks
- "${CHORUS_P2P_PORT:-9000}:9000" # P2P communication - "${CHORUS_P2P_PORT:-9000}:9000" # P2P communication
# Container resource limits # Container resource limits
@@ -51,7 +67,7 @@ services:
update_config: update_config:
parallelism: 1 parallelism: 1
delay: 10s delay: 10s
failure_action: rollback failure_action: pause
order: start-first order: start-first
restart_policy: restart_policy:
condition: on-failure condition: on-failure
@@ -66,10 +82,11 @@ services:
cpus: "0.1" cpus: "0.1"
memory: 128M memory: 128M
placement: placement:
preferences:
- spread: node.id
constraints: constraints:
- node.role == worker - node.hostname != rosewood
preferences:
- spread: node.hostname
# CHORUS is internal-only, no Traefik labels needed
# Network configuration # Network configuration
networks: networks:
@@ -95,16 +112,424 @@ services:
retries: 3 retries: 3
start_period: 10s start_period: 10s
whoosh:
image: anthonyrawlins/whoosh:backbeat-v2.1.0
ports:
- target: 8080
published: 8800
protocol: tcp
mode: ingress
environment:
# Database configuration
WHOOSH_DATABASE_DB_HOST: postgres
WHOOSH_DATABASE_DB_PORT: 5432
WHOOSH_DATABASE_DB_NAME: whoosh
WHOOSH_DATABASE_DB_USER: whoosh
WHOOSH_DATABASE_DB_PASSWORD_FILE: /run/secrets/whoosh_db_password
WHOOSH_DATABASE_DB_SSL_MODE: disable
WHOOSH_DATABASE_DB_AUTO_MIGRATE: "true"
# Server configuration
WHOOSH_SERVER_LISTEN_ADDR: ":8080"
WHOOSH_SERVER_READ_TIMEOUT: "30s"
WHOOSH_SERVER_WRITE_TIMEOUT: "30s"
WHOOSH_SERVER_SHUTDOWN_TIMEOUT: "30s"
# GITEA configuration
WHOOSH_GITEA_BASE_URL: https://gitea.chorus.services
WHOOSH_GITEA_TOKEN_FILE: /run/secrets/gitea_token
WHOOSH_GITEA_WEBHOOK_TOKEN_FILE: /run/secrets/webhook_token
WHOOSH_GITEA_WEBHOOK_PATH: /webhooks/gitea
# Auth configuration
WHOOSH_AUTH_JWT_SECRET_FILE: /run/secrets/jwt_secret
WHOOSH_AUTH_SERVICE_TOKENS_FILE: /run/secrets/service_tokens
WHOOSH_AUTH_JWT_EXPIRY: "24h"
# Logging
WHOOSH_LOGGING_LEVEL: debug
WHOOSH_LOGGING_ENVIRONMENT: production
# Redis configuration
WHOOSH_REDIS_ENABLED: "true"
WHOOSH_REDIS_HOST: redis
WHOOSH_REDIS_PORT: 6379
WHOOSH_REDIS_PASSWORD_FILE: /run/secrets/redis_password
WHOOSH_REDIS_DATABASE: 0
secrets:
- whoosh_db_password
- gitea_token
- webhook_token
- jwt_secret
- service_tokens
- redis_password
deploy:
replicas: 2
restart_policy:
condition: on-failure
delay: 5s
max_attempts: 3
window: 120s
update_config:
parallelism: 1
delay: 10s
failure_action: pause
monitor: 60s
order: start-first
# rollback_config:
# parallelism: 1
# delay: 0s
# failure_action: pause
# monitor: 60s
# order: stop-first
placement:
preferences:
- spread: node.hostname
resources:
limits:
memory: 256M
cpus: '0.5'
reservations:
memory: 128M
cpus: '0.25'
labels:
- traefik.enable=true
- traefik.http.routers.whoosh.rule=Host(`whoosh.chorus.services`)
- traefik.http.routers.whoosh.tls=true
- traefik.http.routers.whoosh.tls.certresolver=letsencrypt
- traefik.http.services.whoosh.loadbalancer.server.port=8080
- traefik.http.middlewares.whoosh-auth.basicauth.users=admin:$$2y$$10$$example_hash
networks:
- tengig
- whoosh-backend
- chorus_net
healthcheck:
test: ["CMD", "/app/whoosh", "--health-check"]
interval: 30s
timeout: 10s
retries: 3
start_period: 40s
postgres:
image: postgres:15-alpine
environment:
POSTGRES_DB: whoosh
POSTGRES_USER: whoosh
POSTGRES_PASSWORD_FILE: /run/secrets/whoosh_db_password
POSTGRES_INITDB_ARGS: --auth-host=scram-sha-256
secrets:
- whoosh_db_password
volumes:
- whoosh_postgres_data:/var/lib/postgresql/data
deploy:
replicas: 1
restart_policy:
condition: on-failure
delay: 5s
max_attempts: 3
window: 120s
placement:
preferences:
- spread: node.hostname
resources:
limits:
memory: 512M
cpus: '1.0'
reservations:
memory: 256M
cpus: '0.5'
networks:
- whoosh-backend
- chorus_net
healthcheck:
test: ["CMD-SHELL", "pg_isready -U whoosh"]
interval: 30s
timeout: 10s
retries: 5
start_period: 30s
redis:
image: redis:7-alpine
command: sh -c 'redis-server --requirepass "$$(cat /run/secrets/redis_password)" --appendonly yes'
secrets:
- redis_password
volumes:
- whoosh_redis_data:/data
deploy:
replicas: 1
restart_policy:
condition: on-failure
delay: 5s
max_attempts: 3
window: 120s
placement:
preferences:
- spread: node.hostname
resources:
limits:
memory: 128M
cpus: '0.25'
reservations:
memory: 64M
cpus: '0.1'
networks:
- whoosh-backend
- chorus_net
healthcheck:
test: ["CMD", "sh", "-c", "redis-cli --no-auth-warning -a $$(cat /run/secrets/redis_password) ping"]
interval: 30s
timeout: 10s
retries: 3
start_period: 30s
# BACKBEAT Pulse Service - Leader-elected tempo broadcaster
# REQ: BACKBEAT-REQ-001 - Single BeatFrame publisher per cluster
# REQ: BACKBEAT-OPS-001 - One replica prefers leadership
backbeat-pulse:
image: anthonyrawlins/backbeat-pulse:v1.0.5
command: >
./pulse
-cluster=chorus-production
-admin-port=8080
-raft-bind=0.0.0.0:9000
-data-dir=/data
-nats=nats://backbeat-nats:4222
-tempo=2
-bar-length=8
-log-level=info
# Internal service ports (not externally exposed - routed via Traefik)
expose:
- "8080" # Admin API
- "9000" # Raft communication
# REQ: BACKBEAT-OPS-002 - Health probes for liveness/readiness
healthcheck:
test: ["CMD", "nc", "-z", "localhost", "8080"]
interval: 30s
timeout: 10s
retries: 3
start_period: 60s
deploy:
replicas: 1 # Single leader with automatic failover
restart_policy:
condition: on-failure
delay: 30s # Wait longer for NATS to be ready
max_attempts: 5
window: 120s
update_config:
parallelism: 1
delay: 30s # Wait for leader election
failure_action: pause
monitor: 60s
order: start-first
placement:
preferences:
- spread: node.hostname
constraints:
- node.hostname != rosewood # Avoid intermittent gaming PC
resources:
limits:
memory: 256M
cpus: '0.5'
reservations:
memory: 128M
cpus: '0.25'
# Traefik routing for admin API
labels:
- traefik.enable=true
- traefik.http.routers.backbeat-pulse.rule=Host(`backbeat-pulse.chorus.services`)
- traefik.http.routers.backbeat-pulse.tls=true
- traefik.http.routers.backbeat-pulse.tls.certresolver=letsencryptresolver
- traefik.http.services.backbeat-pulse.loadbalancer.server.port=8080
networks:
- chorus_net
- tengig # External network for Traefik
# Container logging
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
tag: "backbeat-pulse/{{.Name}}/{{.ID}}"
# BACKBEAT Reverb Service - StatusClaim aggregator
# REQ: BACKBEAT-REQ-020 - Subscribe to INT-B and group by window_id
# REQ: BACKBEAT-OPS-001 - Reverb can scale stateless
backbeat-reverb:
image: anthonyrawlins/backbeat-reverb:v1.0.2
command: >
./reverb
-cluster=chorus-production
-nats=nats://backbeat-nats:4222
-bar-length=8
-log-level=info
# Internal service ports (not externally exposed - routed via Traefik)
expose:
- "8080" # Admin API
# REQ: BACKBEAT-OPS-002 - Health probes for orchestration (temporarily disabled for testing)
# healthcheck:
# test: ["CMD", "nc", "-z", "localhost", "8080"]
# interval: 30s
# timeout: 10s
# retries: 3
# start_period: 60s
deploy:
replicas: 2 # Stateless, can scale horizontally
restart_policy:
condition: on-failure
delay: 10s
max_attempts: 3
window: 120s
update_config:
parallelism: 1
delay: 15s
failure_action: pause
monitor: 45s
order: start-first
placement:
preferences:
- spread: node.hostname
constraints:
- node.hostname != rosewood
resources:
limits:
memory: 512M # Larger for window aggregation
cpus: '1.0'
reservations:
memory: 256M
cpus: '0.5'
# Traefik routing for admin API
labels:
- traefik.enable=true
- traefik.http.routers.backbeat-reverb.rule=Host(`backbeat-reverb.chorus.services`)
- traefik.http.routers.backbeat-reverb.tls=true
- traefik.http.routers.backbeat-reverb.tls.certresolver=letsencryptresolver
- traefik.http.services.backbeat-reverb.loadbalancer.server.port=8080
networks:
- chorus_net
- tengig # External network for Traefik
# Container logging
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
tag: "backbeat-reverb/{{.Name}}/{{.ID}}"
# NATS Message Broker - Use existing or deploy dedicated instance
# REQ: BACKBEAT-INT-001 - Topics via NATS for at-least-once delivery
backbeat-nats:
image: nats:2.9-alpine
command: ["--jetstream"]
deploy:
replicas: 1
restart_policy:
condition: on-failure
delay: 10s
max_attempts: 3
window: 120s
placement:
preferences:
- spread: node.hostname
constraints:
- node.hostname != rosewood
resources:
limits:
memory: 256M
cpus: '0.5'
reservations:
memory: 128M
cpus: '0.25'
networks:
- chorus_net
# Container logging
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
tag: "nats/{{.Name}}/{{.ID}}"
# KACHING services are deployed separately in their own stack
# License validation will access https://kaching.chorus.services/api
# Persistent volumes # Persistent volumes
volumes: volumes:
chorus_data: chorus_data:
driver: local driver: local
whoosh_postgres_data:
driver: local
driver_opts:
type: none
o: bind
device: /rust/containers/WHOOSH/postgres
whoosh_redis_data:
driver: local
driver_opts:
type: none
o: bind
device: /rust/containers/WHOOSH/redis
# Networks for CHORUS communication # Networks for CHORUS communication
networks: networks:
tengig:
external: true
whoosh-backend:
driver: overlay
attachable: false
chorus_net: chorus_net:
driver: overlay driver: overlay
attachable: true attachable: true
ipam: ipam:
config: config:
- subnet: 10.201.0.0/24 - subnet: 10.201.0.0/24
secrets:
chorus_license_id:
external: true
name: chorus_license_id
whoosh_db_password:
external: true
name: whoosh_db_password
gitea_token:
external: true
name: gitea_token
webhook_token:
external: true
name: whoosh_webhook_token
jwt_secret:
external: true
name: whoosh_jwt_secret
service_tokens:
external: true
name: whoosh_service_tokens
redis_password:
external: true
name: whoosh_redis_password

157
go.mod
View File

@@ -1,15 +1,162 @@
module chorus.services/chorus module chorus
go 1.21 go 1.23
toolchain go1.24.5
require ( require (
filippo.io/age v1.2.1 filippo.io/age v1.2.1
github.com/google/go-github/v57 v57.0.0 github.com/blevesearch/bleve/v2 v2.5.3
github.com/chorus-services/backbeat v0.0.0-00010101000000-000000000000
github.com/go-redis/redis/v8 v8.11.5
github.com/google/uuid v1.6.0
github.com/gorilla/mux v1.8.1 github.com/gorilla/mux v1.8.1
github.com/gorilla/websocket v1.5.0
github.com/ipfs/go-cid v0.4.1
github.com/libp2p/go-libp2p v0.32.0 github.com/libp2p/go-libp2p v0.32.0
github.com/libp2p/go-libp2p-kad-dht v0.25.2 github.com/libp2p/go-libp2p-kad-dht v0.25.2
github.com/libp2p/go-libp2p-pubsub v0.10.0 github.com/libp2p/go-libp2p-pubsub v0.10.0
github.com/multiformats/go-multiaddr v0.12.0 github.com/multiformats/go-multiaddr v0.12.0
golang.org/x/oauth2 v0.15.0 github.com/multiformats/go-multihash v0.2.3
gopkg.in/yaml.v2 v2.4.0 github.com/prometheus/client_golang v1.19.1
github.com/robfig/cron/v3 v3.0.1
github.com/sashabaranov/go-openai v1.41.1
github.com/stretchr/testify v1.10.0
github.com/syndtr/goleveldb v1.0.0
golang.org/x/crypto v0.24.0
) )
require (
github.com/RoaringBitmap/roaring/v2 v2.4.5 // indirect
github.com/benbjohnson/clock v1.3.5 // indirect
github.com/beorn7/perks v1.0.1 // indirect
github.com/bits-and-blooms/bitset v1.22.0 // indirect
github.com/blevesearch/bleve_index_api v1.2.8 // indirect
github.com/blevesearch/geo v0.2.4 // indirect
github.com/blevesearch/go-faiss v1.0.25 // indirect
github.com/blevesearch/go-porterstemmer v1.0.3 // indirect
github.com/blevesearch/gtreap v0.1.1 // indirect
github.com/blevesearch/mmap-go v1.0.4 // indirect
github.com/blevesearch/scorch_segment_api/v2 v2.3.10 // indirect
github.com/blevesearch/segment v0.9.1 // indirect
github.com/blevesearch/snowballstem v0.9.0 // indirect
github.com/blevesearch/upsidedown_store_api v1.0.2 // indirect
github.com/blevesearch/vellum v1.1.0 // indirect
github.com/blevesearch/zapx/v11 v11.4.2 // indirect
github.com/blevesearch/zapx/v12 v12.4.2 // indirect
github.com/blevesearch/zapx/v13 v13.4.2 // indirect
github.com/blevesearch/zapx/v14 v14.4.2 // indirect
github.com/blevesearch/zapx/v15 v15.4.2 // indirect
github.com/blevesearch/zapx/v16 v16.2.4 // indirect
github.com/cespare/xxhash/v2 v2.2.0 // indirect
github.com/containerd/cgroups v1.1.0 // indirect
github.com/coreos/go-systemd/v22 v22.5.0 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c // indirect
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/docker/go-units v0.5.0 // indirect
github.com/elastic/gosigar v0.14.2 // indirect
github.com/flynn/noise v1.0.0 // indirect
github.com/francoispqt/gojay v1.2.13 // indirect
github.com/go-logr/logr v1.2.4 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
github.com/godbus/dbus/v5 v5.1.0 // indirect
github.com/gogo/protobuf v1.3.2 // indirect
github.com/golang/protobuf v1.5.3 // indirect
github.com/golang/snappy v0.0.4 // indirect
github.com/google/gopacket v1.1.19 // indirect
github.com/google/pprof v0.0.0-20231023181126-ff6d637d2a7b // indirect
github.com/hashicorp/errwrap v1.1.0 // indirect
github.com/hashicorp/go-multierror v1.1.1 // indirect
github.com/hashicorp/golang-lru v0.5.4 // indirect
github.com/hashicorp/golang-lru/v2 v2.0.5 // indirect
github.com/huin/goupnp v1.3.0 // indirect
github.com/ipfs/boxo v0.10.0 // indirect
github.com/ipfs/go-datastore v0.6.0 // indirect
github.com/ipfs/go-log v1.0.5 // indirect
github.com/ipfs/go-log/v2 v2.5.1 // indirect
github.com/ipld/go-ipld-prime v0.20.0 // indirect
github.com/jackpal/go-nat-pmp v1.0.2 // indirect
github.com/jbenet/go-temp-err-catcher v0.1.0 // indirect
github.com/jbenet/goprocess v0.1.4 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/compress v1.17.2 // indirect
github.com/klauspost/cpuid/v2 v2.2.5 // indirect
github.com/koron/go-ssdp v0.0.4 // indirect
github.com/libp2p/go-buffer-pool v0.1.0 // indirect
github.com/libp2p/go-cidranger v1.1.0 // indirect
github.com/libp2p/go-flow-metrics v0.1.0 // indirect
github.com/libp2p/go-libp2p-asn-util v0.3.0 // indirect
github.com/libp2p/go-libp2p-kbucket v0.6.3 // indirect
github.com/libp2p/go-libp2p-record v0.2.0 // indirect
github.com/libp2p/go-libp2p-routing-helpers v0.7.2 // indirect
github.com/libp2p/go-msgio v0.3.0 // indirect
github.com/libp2p/go-nat v0.2.0 // indirect
github.com/libp2p/go-netroute v0.2.1 // indirect
github.com/libp2p/go-reuseport v0.4.0 // indirect
github.com/libp2p/go-yamux/v4 v4.0.1 // indirect
github.com/libp2p/zeroconf/v2 v2.2.0 // indirect
github.com/marten-seemann/tcp v0.0.0-20210406111302-dfbc87cc63fd // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/miekg/dns v1.1.56 // indirect
github.com/mikioh/tcpinfo v0.0.0-20190314235526-30a79bb1804b // indirect
github.com/mikioh/tcpopt v0.0.0-20190314235656-172688c1accc // indirect
github.com/minio/sha256-simd v1.0.1 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/mr-tron/base58 v1.2.0 // indirect
github.com/mschoch/smat v0.2.0 // indirect
github.com/multiformats/go-base32 v0.1.0 // indirect
github.com/multiformats/go-base36 v0.2.0 // indirect
github.com/multiformats/go-multiaddr-dns v0.3.1 // indirect
github.com/multiformats/go-multiaddr-fmt v0.1.0 // indirect
github.com/multiformats/go-multibase v0.2.0 // indirect
github.com/multiformats/go-multicodec v0.9.0 // indirect
github.com/multiformats/go-multistream v0.5.0 // indirect
github.com/multiformats/go-varint v0.0.7 // indirect
github.com/nats-io/nats.go v1.36.0 // indirect
github.com/nats-io/nkeys v0.4.7 // indirect
github.com/nats-io/nuid v1.0.1 // indirect
github.com/onsi/ginkgo/v2 v2.13.0 // indirect
github.com/opencontainers/runtime-spec v1.1.0 // indirect
github.com/opentracing/opentracing-go v1.2.0 // indirect
github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect
github.com/pkg/errors v0.9.1 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/polydawn/refmt v0.89.0 // indirect
github.com/prometheus/client_model v0.5.0 // indirect
github.com/prometheus/common v0.48.0 // indirect
github.com/prometheus/procfs v0.12.0 // indirect
github.com/quic-go/qpack v0.4.0 // indirect
github.com/quic-go/qtls-go1-20 v0.3.4 // indirect
github.com/quic-go/quic-go v0.39.3 // indirect
github.com/quic-go/webtransport-go v0.6.0 // indirect
github.com/raulk/go-watchdog v1.3.0 // indirect
github.com/spaolacci/murmur3 v1.1.0 // indirect
github.com/whyrusleeping/go-keyspace v0.0.0-20160322163242-5b898ac5add1 // indirect
go.etcd.io/bbolt v1.4.0 // indirect
go.opencensus.io v0.24.0 // indirect
go.opentelemetry.io/otel v1.16.0 // indirect
go.opentelemetry.io/otel/metric v1.16.0 // indirect
go.opentelemetry.io/otel/trace v1.16.0 // indirect
go.uber.org/dig v1.17.1 // indirect
go.uber.org/fx v1.20.1 // indirect
go.uber.org/mock v0.3.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
go.uber.org/zap v1.26.0 // indirect
golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
golang.org/x/mod v0.18.0 // indirect
golang.org/x/net v0.26.0 // indirect
golang.org/x/sync v0.10.0 // indirect
golang.org/x/sys v0.29.0 // indirect
golang.org/x/text v0.16.0 // indirect
golang.org/x/tools v0.22.0 // indirect
gonum.org/v1/gonum v0.13.0 // indirect
google.golang.org/protobuf v1.33.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
lukechampine.com/blake3 v1.2.1 // indirect
)
replace github.com/chorus-services/backbeat => /home/tony/chorus/project-queues/active/BACKBEAT/backbeat/prototype

690
go.sum Normal file
View File

@@ -0,0 +1,690 @@
c2sp.org/CCTV/age v0.0.0-20240306222714-3ec4d716e805 h1:u2qwJeEvnypw+OCPUHmoZE3IqwfuN5kgDfo5MLzpNM0=
c2sp.org/CCTV/age v0.0.0-20240306222714-3ec4d716e805/go.mod h1:FomMrUJ2Lxt5jCLmZkG3FHa72zUprnhd3v/Z18Snm4w=
cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.31.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.37.0/go.mod h1:TS1dMSSfndXH133OKGwekG838Om/cQT0BUHV3HcBgoo=
dmitri.shuralyov.com/app/changes v0.0.0-20180602232624-0a106ad413e3/go.mod h1:Yl+fi1br7+Rr3LqpNJf1/uxUdtRUV+Tnj0o93V2B9MU=
dmitri.shuralyov.com/html/belt v0.0.0-20180602232347-f7d459c86be0/go.mod h1:JLBrvjyP0v+ecvNYvCpyZgu5/xkfAUhi6wJj28eUfSU=
dmitri.shuralyov.com/service/change v0.0.0-20181023043359-a85b471d5412/go.mod h1:a1inKt/atXimZ4Mv927x+r7UpyzRUf4emIoiiSC2TN4=
dmitri.shuralyov.com/state v0.0.0-20180228185332-28bcc343414c/go.mod h1:0PRwlb0D6DFvNNtx+9ybjezNCa8XF0xaYcETyp6rHWU=
filippo.io/age v1.2.1 h1:X0TZjehAZylOIj4DubWYU1vWQxv9bJpo+Uu2/LGhi1o=
filippo.io/age v1.2.1/go.mod h1:JL9ew2lTN+Pyft4RiNGguFfOpewKwSHm5ayKD/A4004=
git.apache.org/thrift.git v0.0.0-20180902110319-2566ecd5d999/go.mod h1:fPE2ZNJGynbRyZ4dJvy6G277gSllfV2HJqblrnkyeyg=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/RoaringBitmap/roaring/v2 v2.4.5 h1:uGrrMreGjvAtTBobc0g5IrW1D5ldxDQYe2JW2gggRdg=
github.com/RoaringBitmap/roaring/v2 v2.4.5/go.mod h1:FiJcsfkGje/nZBZgCu0ZxCPOKD/hVXDS2dXi7/eUFE0=
github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
github.com/benbjohnson/clock v1.3.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
github.com/benbjohnson/clock v1.3.5 h1:VvXlSJBzZpA/zum6Sj74hxwYI2DIxRWuNIoXAzHZz5o=
github.com/benbjohnson/clock v1.3.5/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
github.com/bits-and-blooms/bitset v1.12.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
github.com/bits-and-blooms/bitset v1.22.0 h1:Tquv9S8+SGaS3EhyA+up3FXzmkhxPGjQQCkcs2uw7w4=
github.com/bits-and-blooms/bitset v1.22.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
github.com/blevesearch/bleve/v2 v2.5.3 h1:9l1xtKaETv64SZc1jc4Sy0N804laSa/LeMbYddq1YEM=
github.com/blevesearch/bleve/v2 v2.5.3/go.mod h1:Z/e8aWjiq8HeX+nW8qROSxiE0830yQA071dwR3yoMzw=
github.com/blevesearch/bleve_index_api v1.2.8 h1:Y98Pu5/MdlkRyLM0qDHostYo7i+Vv1cDNhqTeR4Sy6Y=
github.com/blevesearch/bleve_index_api v1.2.8/go.mod h1:rKQDl4u51uwafZxFrPD1R7xFOwKnzZW7s/LSeK4lgo0=
github.com/blevesearch/geo v0.2.4 h1:ECIGQhw+QALCZaDcogRTNSJYQXRtC8/m8IKiA706cqk=
github.com/blevesearch/geo v0.2.4/go.mod h1:K56Q33AzXt2YExVHGObtmRSFYZKYGv0JEN5mdacJJR8=
github.com/blevesearch/go-faiss v1.0.25 h1:lel1rkOUGbT1CJ0YgzKwC7k+XH0XVBHnCVWahdCXk4U=
github.com/blevesearch/go-faiss v1.0.25/go.mod h1:OMGQwOaRRYxrmeNdMrXJPvVx8gBnvE5RYrr0BahNnkk=
github.com/blevesearch/go-porterstemmer v1.0.3 h1:GtmsqID0aZdCSNiY8SkuPJ12pD4jI+DdXTAn4YRcHCo=
github.com/blevesearch/go-porterstemmer v1.0.3/go.mod h1:angGc5Ht+k2xhJdZi511LtmxuEf0OVpvUUNrwmM1P7M=
github.com/blevesearch/gtreap v0.1.1 h1:2JWigFrzDMR+42WGIN/V2p0cUvn4UP3C4Q5nmaZGW8Y=
github.com/blevesearch/gtreap v0.1.1/go.mod h1:QaQyDRAT51sotthUWAH4Sj08awFSSWzgYICSZ3w0tYk=
github.com/blevesearch/mmap-go v1.0.4 h1:OVhDhT5B/M1HNPpYPBKIEJaD0F3Si+CrEKULGCDPWmc=
github.com/blevesearch/mmap-go v1.0.4/go.mod h1:EWmEAOmdAS9z/pi/+Toxu99DnsbhG1TIxUoRmJw/pSs=
github.com/blevesearch/scorch_segment_api/v2 v2.3.10 h1:Yqk0XD1mE0fDZAJXTjawJ8If/85JxnLd8v5vG/jWE/s=
github.com/blevesearch/scorch_segment_api/v2 v2.3.10/go.mod h1:Z3e6ChN3qyN35yaQpl00MfI5s8AxUJbpTR/DL8QOQ+8=
github.com/blevesearch/segment v0.9.1 h1:+dThDy+Lvgj5JMxhmOVlgFfkUtZV2kw49xax4+jTfSU=
github.com/blevesearch/segment v0.9.1/go.mod h1:zN21iLm7+GnBHWTao9I+Au/7MBiL8pPFtJBJTsk6kQw=
github.com/blevesearch/snowballstem v0.9.0 h1:lMQ189YspGP6sXvZQ4WZ+MLawfV8wOmPoD/iWeNXm8s=
github.com/blevesearch/snowballstem v0.9.0/go.mod h1:PivSj3JMc8WuaFkTSRDW2SlrulNWPl4ABg1tC/hlgLs=
github.com/blevesearch/upsidedown_store_api v1.0.2 h1:U53Q6YoWEARVLd1OYNc9kvhBMGZzVrdmaozG2MfoB+A=
github.com/blevesearch/upsidedown_store_api v1.0.2/go.mod h1:M01mh3Gpfy56Ps/UXHjEO/knbqyQ1Oamg8If49gRwrQ=
github.com/blevesearch/vellum v1.1.0 h1:CinkGyIsgVlYf8Y2LUQHvdelgXr6PYuvoDIajq6yR9w=
github.com/blevesearch/vellum v1.1.0/go.mod h1:QgwWryE8ThtNPxtgWJof5ndPfx0/YMBh+W2weHKPw8Y=
github.com/blevesearch/zapx/v11 v11.4.2 h1:l46SV+b0gFN+Rw3wUI1YdMWdSAVhskYuvxlcgpQFljs=
github.com/blevesearch/zapx/v11 v11.4.2/go.mod h1:4gdeyy9oGa/lLa6D34R9daXNUvfMPZqUYjPwiLmekwc=
github.com/blevesearch/zapx/v12 v12.4.2 h1:fzRbhllQmEMUuAQ7zBuMvKRlcPA5ESTgWlDEoB9uQNE=
github.com/blevesearch/zapx/v12 v12.4.2/go.mod h1:TdFmr7afSz1hFh/SIBCCZvcLfzYvievIH6aEISCte58=
github.com/blevesearch/zapx/v13 v13.4.2 h1:46PIZCO/ZuKZYgxI8Y7lOJqX3Irkc3N8W82QTK3MVks=
github.com/blevesearch/zapx/v13 v13.4.2/go.mod h1:knK8z2NdQHlb5ot/uj8wuvOq5PhDGjNYQQy0QDnopZk=
github.com/blevesearch/zapx/v14 v14.4.2 h1:2SGHakVKd+TrtEqpfeq8X+So5PShQ5nW6GNxT7fWYz0=
github.com/blevesearch/zapx/v14 v14.4.2/go.mod h1:rz0XNb/OZSMjNorufDGSpFpjoFKhXmppH9Hi7a877D8=
github.com/blevesearch/zapx/v15 v15.4.2 h1:sWxpDE0QQOTjyxYbAVjt3+0ieu8NCE0fDRaFxEsp31k=
github.com/blevesearch/zapx/v15 v15.4.2/go.mod h1:1pssev/59FsuWcgSnTa0OeEpOzmhtmr/0/11H0Z8+Nw=
github.com/blevesearch/zapx/v16 v16.2.4 h1:tGgfvleXTAkwsD5mEzgM3zCS/7pgocTCnO1oyAUjlww=
github.com/blevesearch/zapx/v16 v16.2.4/go.mod h1:Rti/REtuuMmzwsI8/C/qIzRaEoSK/wiFYw5e5ctUKKs=
github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/cilium/ebpf v0.2.0/go.mod h1:To2CFviqOWL/M0gIMsvSMlqe7em/l1ALkX1PyjrX2Qs=
github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
github.com/containerd/cgroups v0.0.0-20201119153540-4cbc285b3327/go.mod h1:ZJeTFisyysqgcCdecO57Dj79RfL0LNeGiFUqLYQRYLE=
github.com/containerd/cgroups v1.1.0 h1:v8rEWFl6EoqHB+swVNjVoCJE8o3jX7e8nqBGPLaDFBM=
github.com/containerd/cgroups v1.1.0/go.mod h1:6ppBcbh/NOOUU+dMKrykgaBnK9lCIBxHqJDGwsa1mIw=
github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
github.com/coreos/go-systemd/v22 v22.1.0/go.mod h1:xO0FLkIi5MaZafQlIrOotqXZ90ih+1atmu1JpKERPPk=
github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=
github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c h1:pFUpOrbxDR6AkioZ1ySsx5yxlDQZ8stG2b88gTPxgJU=
github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c/go.mod h1:6UhI8N9EjYm1c2odKpFpAYeR8dsBeM7PtzQhRgxRr9U=
github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y=
github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs=
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
github.com/elastic/gosigar v0.12.0/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
github.com/elastic/gosigar v0.14.2 h1:Dg80n8cr90OZ7x+bAax/QjoW/XqTI11RmA79ZwIm9/4=
github.com/elastic/gosigar v0.14.2/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
github.com/flynn/noise v1.0.0 h1:DlTHqmzmvcEiKj+4RYo/imoswx/4r6iBlCMfVtrMXpQ=
github.com/flynn/noise v1.0.0/go.mod h1:xbMo+0i6+IGbYdJhF31t2eR1BIU0CYc12+BNAKwUTag=
github.com/francoispqt/gojay v1.2.13 h1:d2m3sFjloqoIUQU3TsHBgj6qg/BVGlTBeHDUmyJnXKk=
github.com/francoispqt/gojay v1.2.13/go.mod h1:ehT5mTG4ua4581f1++1WLG0vPdaA9HaiDsoyrBGkyDY=
github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY=
github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI=
github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI=
github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
github.com/go-yaml/yaml v2.1.0+incompatible/go.mod h1:w2MrLa16VYP0jy6N7M5kHaCkaLENm+P+Tv+MfurjSw0=
github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/gopacket v1.1.19 h1:ves8RnFZPGiFnTS0uPQStjwru6uO6h+nlr9j6fL7kF8=
github.com/google/gopacket v1.1.19/go.mod h1:iJ8V8n6KS+z2U1A8pUwu8bW5SyEMkXJB8Yo/Vo+TKTo=
github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
github.com/google/pprof v0.0.0-20231023181126-ff6d637d2a7b h1:RMpPgZTSApbPf7xaVel+QkoGPRLFLrwFO89uDUHEGf0=
github.com/google/pprof v0.0.0-20231023181126-ff6d637d2a7b/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik=
github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
github.com/googleapis/gax-go/v2 v2.0.3/go.mod h1:LLvjysVCY1JZeum8Z6l8qUty8fiNwE08qbEPm1M08qg=
github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
github.com/gopherjs/gopherjs v0.0.0-20190430165422-3e4dfb77656c h1:7lF+Vz0LqiRidnzC1Oq86fpX1q/iEv2KJdrCtttYjT4=
github.com/gopherjs/gopherjs v0.0.0-20190430165422-3e4dfb77656c/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
github.com/grpc-ecosystem/grpc-gateway v1.5.0/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=
github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
github.com/hashicorp/golang-lru/v2 v2.0.5 h1:wW7h1TG88eUIJ2i69gaE3uNVtEPIagzhGvHgwfx2Vm4=
github.com/hashicorp/golang-lru/v2 v2.0.5/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc=
github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8=
github.com/ipfs/boxo v0.10.0 h1:tdDAxq8jrsbRkYoF+5Rcqyeb91hgWe2hp7iLu7ORZLY=
github.com/ipfs/boxo v0.10.0/go.mod h1:Fg+BnfxZ0RPzR0nOodzdIq3A7KgoWAOWsEIImrIQdBM=
github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s=
github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk=
github.com/ipfs/go-datastore v0.6.0 h1:JKyz+Gvz1QEZw0LsX1IBn+JFCJQH4SJVFtM4uWU0Myk=
github.com/ipfs/go-datastore v0.6.0/go.mod h1:rt5M3nNbSO/8q1t4LNkLyUwRs8HupMeN/8O4Vn9YAT8=
github.com/ipfs/go-detect-race v0.0.1 h1:qX/xay2W3E4Q1U7d9lNs1sU9nvguX0a7319XbyQ6cOk=
github.com/ipfs/go-detect-race v0.0.1/go.mod h1:8BNT7shDZPo99Q74BpGMK+4D8Mn4j46UU0LZ723meps=
github.com/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8=
github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ=
github.com/ipfs/go-log v1.0.5 h1:2dOuUCB1Z7uoczMWgAyDck5JLb72zHzrMnGnCNNbvY8=
github.com/ipfs/go-log v1.0.5/go.mod h1:j0b8ZoR+7+R99LD9jZ6+AJsrzkPbSXbZfGakb5JPtIo=
github.com/ipfs/go-log/v2 v2.1.3/go.mod h1:/8d0SH3Su5Ooc31QlL1WysJhvyOTDCjcCZ9Axpmri6g=
github.com/ipfs/go-log/v2 v2.5.1 h1:1XdUzF7048prq4aBjDQQ4SL5RxftpRGdXhNRwKSAlcY=
github.com/ipfs/go-log/v2 v2.5.1/go.mod h1:prSpmC1Gpllc9UYWxDiZDreBYw7zp4Iqp1kOLU9U5UI=
github.com/ipld/go-ipld-prime v0.20.0 h1:Ud3VwE9ClxpO2LkCYP7vWPc0Fo+dYdYzgxUJZ3uRG4g=
github.com/ipld/go-ipld-prime v0.20.0/go.mod h1:PzqZ/ZR981eKbgdr3y2DJYeD/8bgMawdGVlJDE8kK+M=
github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
github.com/jbenet/go-cienv v0.1.0/go.mod h1:TqNnHUmJgXau0nCzC7kXWeotg3J9W34CUv5Djy1+FlA=
github.com/jbenet/go-temp-err-catcher v0.1.0 h1:zpb3ZH6wIE8Shj2sKS+khgRvf7T7RABoLk/+KKHggpk=
github.com/jbenet/go-temp-err-catcher v0.1.0/go.mod h1:0kJRvmDZXNMIiJirNPEYfhpPwbGVtZVWC34vc5WLsDk=
github.com/jbenet/goprocess v0.1.4 h1:DRGOFReOMqqDNXwW70QkacFW0YN9QnwLV0Vqk+3oU0o=
github.com/jbenet/goprocess v0.1.4/go.mod h1:5yspPrukOVuOLORacaBi858NqyClJPQxYZlqdZVfqY4=
github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU=
github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
github.com/klauspost/compress v1.17.2 h1:RlWWUY/Dr4fL8qk9YG7DTZ7PDgME2V4csBXA8L/ixi4=
github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg=
github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
github.com/koron/go-ssdp v0.0.4 h1:1IDwrghSKYM7yLf7XCzbByg2sJ/JcNOZRXS2jczTwz0=
github.com/koron/go-ssdp v0.0.4/go.mod h1:oDXq+E5IL5q0U8uSBcoAXzTzInwy5lEgC91HoKtbmZk=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8=
github.com/libp2p/go-buffer-pool v0.1.0/go.mod h1:N+vh8gMqimBzdKkSMVuydVDq+UV5QTWy5HSiZacSbPg=
github.com/libp2p/go-cidranger v1.1.0 h1:ewPN8EZ0dd1LSnrtuwd4709PXVcITVeuwbag38yPW7c=
github.com/libp2p/go-cidranger v1.1.0/go.mod h1:KWZTfSr+r9qEo9OkI9/SIEeAtw+NNoU0dXIXt15Okic=
github.com/libp2p/go-flow-metrics v0.1.0 h1:0iPhMI8PskQwzh57jB9WxIuIOQ0r+15PChFGkx3Q3WM=
github.com/libp2p/go-flow-metrics v0.1.0/go.mod h1:4Xi8MX8wj5aWNDAZttg6UPmc0ZrnFNsMtpsYUClFtro=
github.com/libp2p/go-libp2p v0.32.0 h1:86I4B7nBUPIyTgw3+5Ibq6K7DdKRCuZw8URCfPc1hQM=
github.com/libp2p/go-libp2p v0.32.0/go.mod h1:hXXC3kXPlBZ1eu8Q2hptGrMB4mZ3048JUoS4EKaHW5c=
github.com/libp2p/go-libp2p-asn-util v0.3.0 h1:gMDcMyYiZKkocGXDQ5nsUQyquC9+H+iLEQHwOCZ7s8s=
github.com/libp2p/go-libp2p-asn-util v0.3.0/go.mod h1:B1mcOrKUE35Xq/ASTmQ4tN3LNzVVaMNmq2NACuqyB9w=
github.com/libp2p/go-libp2p-kad-dht v0.25.2 h1:FOIk9gHoe4YRWXTu8SY9Z1d0RILol0TrtApsMDPjAVQ=
github.com/libp2p/go-libp2p-kad-dht v0.25.2/go.mod h1:6za56ncRHYXX4Nc2vn8z7CZK0P4QiMcrn77acKLM2Oo=
github.com/libp2p/go-libp2p-kbucket v0.6.3 h1:p507271wWzpy2f1XxPzCQG9NiN6R6lHL9GiSErbQQo0=
github.com/libp2p/go-libp2p-kbucket v0.6.3/go.mod h1:RCseT7AH6eJWxxk2ol03xtP9pEHetYSPXOaJnOiD8i0=
github.com/libp2p/go-libp2p-pubsub v0.10.0 h1:wS0S5FlISavMaAbxyQn3dxMOe2eegMfswM471RuHJwA=
github.com/libp2p/go-libp2p-pubsub v0.10.0/go.mod h1:1OxbaT/pFRO5h+Dpze8hdHQ63R0ke55XTs6b6NwLLkw=
github.com/libp2p/go-libp2p-record v0.2.0 h1:oiNUOCWno2BFuxt3my4i1frNrt7PerzB3queqa1NkQ0=
github.com/libp2p/go-libp2p-record v0.2.0/go.mod h1:I+3zMkvvg5m2OcSdoL0KPljyJyvNDFGKX7QdlpYUcwk=
github.com/libp2p/go-libp2p-routing-helpers v0.7.2 h1:xJMFyhQ3Iuqnk9Q2dYE1eUTzsah7NLw3Qs2zjUV78T0=
github.com/libp2p/go-libp2p-routing-helpers v0.7.2/go.mod h1:cN4mJAD/7zfPKXBcs9ze31JGYAZgzdABEm+q/hkswb8=
github.com/libp2p/go-libp2p-testing v0.12.0 h1:EPvBb4kKMWO29qP4mZGyhVzUyR25dvfUIK5WDu6iPUA=
github.com/libp2p/go-libp2p-testing v0.12.0/go.mod h1:KcGDRXyN7sQCllucn1cOOS+Dmm7ujhfEyXQL5lvkcPg=
github.com/libp2p/go-msgio v0.3.0 h1:mf3Z8B1xcFN314sWX+2vOTShIE0Mmn2TXn3YCUQGNj0=
github.com/libp2p/go-msgio v0.3.0/go.mod h1:nyRM819GmVaF9LX3l03RMh10QdOroF++NBbxAb0mmDM=
github.com/libp2p/go-nat v0.2.0 h1:Tyz+bUFAYqGyJ/ppPPymMGbIgNRH+WqC5QrT5fKrrGk=
github.com/libp2p/go-nat v0.2.0/go.mod h1:3MJr+GRpRkyT65EpVPBstXLvOlAPzUVlG6Pwg9ohLJk=
github.com/libp2p/go-netroute v0.2.1 h1:V8kVrpD8GK0Riv15/7VN6RbUQ3URNZVosw7H2v9tksU=
github.com/libp2p/go-netroute v0.2.1/go.mod h1:hraioZr0fhBjG0ZRXJJ6Zj2IVEVNx6tDTFQfSmcq7mQ=
github.com/libp2p/go-reuseport v0.4.0 h1:nR5KU7hD0WxXCJbmw7r2rhRYruNRl2koHw8fQscQm2s=
github.com/libp2p/go-reuseport v0.4.0/go.mod h1:ZtI03j/wO5hZVDFo2jKywN6bYKWLOy8Se6DrI2E1cLU=
github.com/libp2p/go-yamux/v4 v4.0.1 h1:FfDR4S1wj6Bw2Pqbc8Uz7pCxeRBPbwsBbEdfwiCypkQ=
github.com/libp2p/go-yamux/v4 v4.0.1/go.mod h1:NWjl8ZTLOGlozrXSOZ/HlfG++39iKNnM5wwmtQP1YB4=
github.com/libp2p/zeroconf/v2 v2.2.0 h1:Cup06Jv6u81HLhIj1KasuNM/RHHrJ8T7wOTS4+Tv53Q=
github.com/libp2p/zeroconf/v2 v2.2.0/go.mod h1:fuJqLnUwZTshS3U/bMRJ3+ow/v9oid1n0DmyYyNO1Xs=
github.com/lunixbochs/vtclean v1.0.0/go.mod h1:pHhQNgMf3btfWnGBVipUOjRYhoOsdGqdm/+2c2E2WMI=
github.com/mailru/easyjson v0.0.0-20190312143242-1de009706dbe/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
github.com/marten-seemann/tcp v0.0.0-20210406111302-dfbc87cc63fd h1:br0buuQ854V8u83wA0rVZ8ttrq5CpaPZdvrK0LP2lOk=
github.com/marten-seemann/tcp v0.0.0-20210406111302-dfbc87cc63fd/go.mod h1:QuCEs1Nt24+FYQEqAAncTDPJIuGs+LxK1MCiFL25pMU=
github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
github.com/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00vh2OMYv+xgHpAMF4=
github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI=
github.com/miekg/dns v1.1.43/go.mod h1:+evo5L0630/F6ca/Z9+GAqzhjGyn8/c+TBaOyfEl0V4=
github.com/miekg/dns v1.1.56 h1:5imZaSeoRNvpM9SzWNhEcP9QliKiz20/dA2QabIGVnE=
github.com/miekg/dns v1.1.56/go.mod h1:cRm6Oo2C8TY9ZS/TqsSrseAcncm74lfK5G+ikN2SWWY=
github.com/mikioh/tcp v0.0.0-20190314235350-803a9b46060c h1:bzE/A84HN25pxAuk9Eej1Kz9OUelF97nAc82bDquQI8=
github.com/mikioh/tcp v0.0.0-20190314235350-803a9b46060c/go.mod h1:0SQS9kMwD2VsyFEB++InYyBJroV/FRmBgcydeSUcJms=
github.com/mikioh/tcpinfo v0.0.0-20190314235526-30a79bb1804b h1:z78hV3sbSMAUoyUMM0I83AUIT6Hu17AWfgjzIbtrYFc=
github.com/mikioh/tcpinfo v0.0.0-20190314235526-30a79bb1804b/go.mod h1:lxPUiZwKoFL8DUUmalo2yJJUCxbPKtm8OKfqr2/FTNU=
github.com/mikioh/tcpopt v0.0.0-20190314235656-172688c1accc h1:PTfri+PuQmWDqERdnNMiD9ZejrlswWrCpBEZgWOiTrc=
github.com/mikioh/tcpopt v0.0.0-20190314235656-172688c1accc/go.mod h1:cGKTAVKx4SxOuR/czcZ/E2RSJ3sfHs8FpHhQ5CWMf9s=
github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM=
github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/mr-tron/base58 v1.1.2/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
github.com/mschoch/smat v0.2.0 h1:8imxQsjDm8yFEAVBe7azKmKSgzSkZXDuKkSq9374khM=
github.com/mschoch/smat v0.2.0/go.mod h1:kc9mz7DoBKqDyiRL7VZN8KvXQMWeTaVnttLRXOlotKw=
github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE=
github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI=
github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0=
github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4=
github.com/multiformats/go-multiaddr v0.1.1/go.mod h1:aMKBKNEYmzmDmxfX88/vz+J5IU55txyt0p4aiWVohjo=
github.com/multiformats/go-multiaddr v0.2.0/go.mod h1:0nO36NvPpyV4QzvTLi/lafl2y95ncPj0vFwVF6k6wJ4=
github.com/multiformats/go-multiaddr v0.12.0 h1:1QlibTFkoXJuDjjYsMHhE73TnzJQl8FSWatk/0gxGzE=
github.com/multiformats/go-multiaddr v0.12.0/go.mod h1:WmZXgObOQOYp9r3cslLlppkrz1FYSHmE834dfz/lWu8=
github.com/multiformats/go-multiaddr-dns v0.3.1 h1:QgQgR+LQVt3NPTjbrLLpsaT2ufAA2y0Mkk+QRVJbW3A=
github.com/multiformats/go-multiaddr-dns v0.3.1/go.mod h1:G/245BRQ6FJGmryJCrOuTdB37AMA5AMOVuO6NY3JwTk=
github.com/multiformats/go-multiaddr-fmt v0.1.0 h1:WLEFClPycPkp4fnIzoFoV9FVd49/eQsuaL3/CWe167E=
github.com/multiformats/go-multiaddr-fmt v0.1.0/go.mod h1:hGtDIW4PU4BqJ50gW2quDuPVjyWNZxToGUh/HwTZYJo=
github.com/multiformats/go-multibase v0.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivncJHmHnnd87g=
github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk=
github.com/multiformats/go-multicodec v0.9.0 h1:pb/dlPnzee/Sxv/j4PmkDRxCOi3hXTz3IbPKOXWJkmg=
github.com/multiformats/go-multicodec v0.9.0/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k=
github.com/multiformats/go-multihash v0.0.8/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew=
github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U=
github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM=
github.com/multiformats/go-multistream v0.5.0 h1:5htLSLl7lvJk3xx3qT/8Zm9J4K8vEOf/QGkvOGQAyiE=
github.com/multiformats/go-multistream v0.5.0/go.mod h1:n6tMZiwiP2wUsR8DgfDWw1dydlEqV3l6N3/GBsX6ILA=
github.com/multiformats/go-varint v0.0.1/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8=
github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU=
github.com/nats-io/nats.go v1.36.0 h1:suEUPuWzTSse/XhESwqLxXGuj8vGRuPRoG7MoRN/qyU=
github.com/nats-io/nats.go v1.36.0/go.mod h1:Ubdu4Nh9exXdSz0RVWRFBbRfrbSxOYd26oF0wkWclB8=
github.com/nats-io/nkeys v0.4.7 h1:RwNJbbIdYCoClSDNY7QVKZlyb/wfT6ugvFCiKy6vDvI=
github.com/nats-io/nkeys v0.4.7/go.mod h1:kqXRgRDPlGy7nGaEDMuYzmiJCIAAWDK0IMBtDmGD0nc=
github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo=
github.com/neelance/sourcemap v0.0.0-20151028013722-8c68805598ab/go.mod h1:Qr6/a/Q4r9LP1IltGz7tA7iOK1WonHEYhu1HRBA7ZiM=
github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
github.com/onsi/ginkgo/v2 v2.13.0 h1:0jY9lJquiL8fcf3M4LAXN5aMlS/b2BV86HFFPCPMgE4=
github.com/onsi/ginkgo/v2 v2.13.0/go.mod h1:TE309ZR8s5FsKKpuB1YAQYBzCaAfUgatB/xlT/ETL/o=
github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI=
github.com/onsi/gomega v1.27.10/go.mod h1:RsS8tutOdbdgzbPtzzATp12yT7kM5I5aElG3evPbQ0M=
github.com/opencontainers/runtime-spec v1.0.2/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
github.com/opencontainers/runtime-spec v1.1.0 h1:HHUyrt9mwHUjtasSbXSMvs4cyFxh+Bll4AjJ9odEGpg=
github.com/opencontainers/runtime-spec v1.1.0/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs=
github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=
github.com/openzipkin/zipkin-go v0.1.1/go.mod h1:NtoC/o8u3JlF1lSlyPNswIbeQH9bJTmOf0Erfk+hxe8=
github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 h1:onHthvaw9LFnH4t2DcNVpwGmV9E1BkGknEliJkfwQj0=
github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58/go.mod h1:DXv8WO4yhMYhSNPKjeNKa5WY9YCIEBRbNzFFPJbWO6Y=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/polydawn/refmt v0.89.0 h1:ADJTApkvkeBZsN0tBTx8QjpD9JkmxbKp0cxfr9qszm4=
github.com/polydawn/refmt v0.89.0/go.mod h1:/zvteZs/GwLtCgZ4BL6CBsk9IKIlexP43ObX9AxTqTw=
github.com/prometheus/client_golang v0.8.0/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw=
github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI=
github.com/prometheus/common v0.0.0-20180801064454-c7de2306084e/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE=
github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc=
github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
github.com/quic-go/qtls-go1-20 v0.3.4 h1:MfFAPULvst4yoMgY9QmtpYmfij/em7O8UUi+bNVm7Cg=
github.com/quic-go/qtls-go1-20 v0.3.4/go.mod h1:X9Nh97ZL80Z+bX/gUXMbipO6OxdiDi58b/fMC9mAL+k=
github.com/quic-go/quic-go v0.39.3 h1:o3YB6t2SR+HU/pgwF29kJ6g4jJIJEwEZ8CKia1h1TKg=
github.com/quic-go/quic-go v0.39.3/go.mod h1:T09QsDQWjLiQ74ZmacDfqZmhY/NLnw5BC40MANNNZ1Q=
github.com/quic-go/webtransport-go v0.6.0 h1:CvNsKqc4W2HljHJnoT+rMmbRJybShZ0YPFDD3NxaZLY=
github.com/quic-go/webtransport-go v0.6.0/go.mod h1:9KjU4AEBqEQidGHNDkZrb8CAa1abRaosM2yGOyiikEc=
github.com/raulk/go-watchdog v1.3.0 h1:oUmdlHxdkXRJlwfG0O9omj8ukerm8MEQavSiDTEtBsk=
github.com/raulk/go-watchdog v1.3.0/go.mod h1:fIvOnLbF0b0ZwkB9YU4mOW9Did//4vPZtDqv66NfsMU=
github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/sashabaranov/go-openai v1.41.1 h1:zf5tM+GuxpyiyD9XZg8nCqu52eYFQg9OOew0gnIuDy4=
github.com/sashabaranov/go-openai v1.41.1/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
github.com/shurcooL/component v0.0.0-20170202220835-f88ec8f54cc4/go.mod h1:XhFIlyj5a1fBNx5aJTbKoIq0mNaPvOagO+HjB3EtxrY=
github.com/shurcooL/events v0.0.0-20181021180414-410e4ca65f48/go.mod h1:5u70Mqkb5O5cxEA8nxTsgrgLehJeAw6Oc4Ab1c/P1HM=
github.com/shurcooL/github_flavored_markdown v0.0.0-20181002035957-2122de532470/go.mod h1:2dOwnU2uBioM+SGy2aZoq1f/Sd1l9OkAeAUvjSyvgU0=
github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=
github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ=
github.com/shurcooL/gofontwoff v0.0.0-20180329035133-29b52fc0a18d/go.mod h1:05UtEgK5zq39gLST6uB0cf3NEHjETfB4Fgr3Gx5R9Vw=
github.com/shurcooL/gopherjslib v0.0.0-20160914041154-feb6d3990c2c/go.mod h1:8d3azKNyqcHP1GaQE/c6dDgjkgSx2BZ4IoEi4F1reUI=
github.com/shurcooL/highlight_diff v0.0.0-20170515013008-09bb4053de1b/go.mod h1:ZpfEhSmds4ytuByIcDnOLkTHGUI6KNqRNPDLHDk+mUU=
github.com/shurcooL/highlight_go v0.0.0-20181028180052-98c3abbbae20/go.mod h1:UDKB5a1T23gOMUJrI+uSuH0VRDStOiUVSjBTRDVBVag=
github.com/shurcooL/home v0.0.0-20181020052607-80b7ffcb30f9/go.mod h1:+rgNQw2P9ARFAs37qieuu7ohDNQ3gds9msbT2yn85sg=
github.com/shurcooL/htmlg v0.0.0-20170918183704-d01228ac9e50/go.mod h1:zPn1wHpTIePGnXSHpsVPWEktKXHr6+SS6x/IKRb7cpw=
github.com/shurcooL/httperror v0.0.0-20170206035902-86b7830d14cc/go.mod h1:aYMfkZ6DWSJPJ6c4Wwz3QtW22G7mf/PEgaB9k/ik5+Y=
github.com/shurcooL/httpfs v0.0.0-20171119174359-809beceb2371/go.mod h1:ZY1cvUeJuFPAdZ/B6v7RHavJWZn2YPVFQ1OSXhCGOkg=
github.com/shurcooL/httpgzip v0.0.0-20180522190206-b1c53ac65af9/go.mod h1:919LwcH0M7/W4fcZ0/jy0qGght1GIhqyS/EgWGH2j5Q=
github.com/shurcooL/issues v0.0.0-20181008053335-6292fdc1e191/go.mod h1:e2qWDig5bLteJ4fwvDAc2NHzqFEthkqn7aOZAOpj+PQ=
github.com/shurcooL/issuesapp v0.0.0-20180602232740-048589ce2241/go.mod h1:NPpHK2TI7iSaM0buivtFUc9offApnI0Alt/K8hcHy0I=
github.com/shurcooL/notifications v0.0.0-20181007000457-627ab5aea122/go.mod h1:b5uSkrEVM1jQUspwbixRBhaIjIzL2xazXp6kntxYle0=
github.com/shurcooL/octicon v0.0.0-20181028054416-fa4f57f9efb2/go.mod h1:eWdoE5JD4R5UVWDucdOPg1g2fqQRq78IQa9zlOV1vpQ=
github.com/shurcooL/reactions v0.0.0-20181006231557-f2e0b4ca5b82/go.mod h1:TCR1lToEk4d2s07G3XGfz2QrgHXg4RJBvjrOozvoWfk=
github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
github.com/shurcooL/users v0.0.0-20180125191416-49c67e49c537/go.mod h1:QJTqeLYEDaXHZDBsXlPCDqdhQuJkuw4NOtaxYe3xii4=
github.com/shurcooL/webdavfs v0.0.0-20170829043945-18c3829fa133/go.mod h1:hKmq5kWdCj2z2KEozexVbfEZIWiTjhE0+UjmZgPqehw=
github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
github.com/smartystreets/assertions v1.2.0 h1:42S6lae5dvLc7BrLu/0ugRtcFVjoJNMC/N3yZFZkDFs=
github.com/smartystreets/assertions v1.2.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo=
github.com/smartystreets/goconvey v1.7.2 h1:9RBaZCeXEQ3UselpuwUQHltGVXvdwm6cv1hgR6gDIPg=
github.com/smartystreets/goconvey v1.7.2/go.mod h1:Vw0tHAZW6lzCRk3xgdin6fKYcG+G3Pg9vgXWeJpQFMM=
github.com/sourcegraph/annotate v0.0.0-20160123013949-f4cad6c6324d/go.mod h1:UdhH50NIW0fCiwBSr0co2m7BnFLdv4fQTgdqdJTHFeE=
github.com/sourcegraph/syntaxhighlight v0.0.0-20170531221838-bd320f5d308e/go.mod h1:HuIsMU8RRBOtsCgI77wP899iHVBQpCmg4ErYMZB+2IA=
github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE=
github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ=
github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
github.com/urfave/cli v1.22.10/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49uaYMPRU=
github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM=
github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0 h1:GDDkbFiaK8jsSDJfjId/PEGEShv6ugrt4kYsC5UIDaQ=
github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=
github.com/whyrusleeping/go-keyspace v0.0.0-20160322163242-5b898ac5add1 h1:EKhdznlJHPMoKr0XTrX+IlJs1LH3lyx2nfr1dOlZ79k=
github.com/whyrusleeping/go-keyspace v0.0.0-20160322163242-5b898ac5add1/go.mod h1:8UvriyWtv5Q5EOgjHaSseUEdkQfvwFv1I/In/O2M9gc=
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
go.etcd.io/bbolt v1.4.0 h1:TU77id3TnN/zKr7CO/uk+fBCwF2jGcMuw2B/FMAzYIk=
go.etcd.io/bbolt v1.4.0/go.mod h1:AsD+OCi/qPN1giOX1aiLAha3o1U8rAz65bvN4j0sRuk=
go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA=
go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
go.opentelemetry.io/otel v1.16.0 h1:Z7GVAX/UkAXPKsy94IU+i6thsQS4nb7LviLpnaNeW8s=
go.opentelemetry.io/otel v1.16.0/go.mod h1:vl0h9NUa1D5s1nv3A5vZOYWn8av4K8Ml6JDeHrT/bx4=
go.opentelemetry.io/otel/metric v1.16.0 h1:RbrpwVG1Hfv85LgnZ7+txXioPDoh6EdbZHo26Q3hqOo=
go.opentelemetry.io/otel/metric v1.16.0/go.mod h1:QE47cpOmkwipPiefDwo2wDzwJrlfxxNYodqc4xnGCo4=
go.opentelemetry.io/otel/trace v1.16.0 h1:8JRpaObFoW0pxuVPapkgH8UhHQj+bJW8jJsCZEu5MQs=
go.opentelemetry.io/otel/trace v1.16.0/go.mod h1:Yt9vYq1SdNz3xdjZZK7wcXv1qv2pwLkqr2QVwea0ef0=
go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
go.uber.org/dig v1.17.1 h1:Tga8Lz8PcYNsWsyHMZ1Vm0OQOUaJNDyvPImgbAu9YSc=
go.uber.org/dig v1.17.1/go.mod h1:Us0rSJiThwCv2GteUN0Q7OKvU7n5J4dxZ9JKUXozFdE=
go.uber.org/fx v1.20.1 h1:zVwVQGS8zYvhh9Xxcu4w1M6ESyeMzebzj2NbSayZ4Mk=
go.uber.org/fx v1.20.1/go.mod h1:iSYNbHf2y55acNCwCXKx7LbWb5WG1Bnue5RDXz1OREg=
go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk=
go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo=
go.uber.org/mock v0.3.0 h1:3mUxI1No2/60yUYax92Pt8eNOEecx2D3lcXZh2NEZJo=
go.uber.org/mock v0.3.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
go.uber.org/zap v1.16.0/go.mod h1:MA8QOfq0BHJwdXa996Y4dYkAqRKB8/1K1QMMZVaNZjQ=
go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI=
go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo=
go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so=
go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
golang.org/x/build v0.0.0-20190111050920-041ab4dc3f9d/go.mod h1:OWs+y06UdEOHN4y+MfF/py+xQ/tYqIWW03b70/CG9Rw=
golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200602180216-279210d13fed/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181029044818-c44066c5c816/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181106065722-10aee1819953/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
golang.org/x/net v0.0.0-20210423184538-5f58ad60dda6/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.0.0-20180810173357-98c5dad5d1a0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181029174526-d69651ed3497/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190316082340-a2f829d7f35f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210303074136-134d130e1a04/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210426080607-c94f62235c83/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA=
golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181030000716-a0a13e073c7b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
gonum.org/v1/gonum v0.13.0 h1:a0T3bh+7fhRyqeNbiC3qVHYmkiQgit3wnNan/2c0HMM=
gonum.org/v1/gonum v0.13.0/go.mod h1:/WPYRckkfWrhWefxyYTfrTtQR0KH4iyHNuzxqXAKyAU=
google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
google.golang.org/api v0.0.0-20181030000543-1d582fd0359e/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
google.golang.org/api v0.1.0/go.mod h1:UGEZY7KEX120AnNLIHFMKIo4obdJhkp2tPbaPlQx13Y=
google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20181029155118-b69ba1387ce2/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20181202183823-bd91e49a0898/go.mod h1:7Ep/1NZk928CDR8SjdVbjWNpdIf6nzjE3BTgJDr2Atg=
google.golang.org/genproto v0.0.0-20190306203927-b5d61aea6440/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
google.golang.org/grpc v1.16.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio=
google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
lukechampine.com/blake3 v1.2.1 h1:YuqqRuaqsGV71BV/nm9xlI0MKUv4QC54jQnBChWbGnI=
lukechampine.com/blake3 v1.2.1/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k=
sourcegraph.com/sourcegraph/go-diff v0.5.0/go.mod h1:kuch7UrkMzY0X+p9CRK03kfuPQ2zzQcaEFbx8wA8rck=
sourcegraph.com/sqs/pbtypes v0.0.0-20180604144634-d3ebe8f20ae4/go.mod h1:ketZ/q3QxT9HOBeFhu6RdvsftgpsbFHBF5Cas6cDKZ0=

4
internal/agent/agent.go
View File

@@ -6,8 +6,8 @@ import (
"net/http" "net/http"
"time" "time"
"chorus.services/chorus/internal/config" "chorus/internal/config"
"chorus.services/chorus/internal/logging" "chorus/internal/logging"
) )
// Agent represents a CHORUS agent instance // Agent represents a CHORUS agent instance

400
internal/backbeat/integration.go Normal file
View File

@@ -0,0 +1,400 @@
package backbeat
import (
"context"
"fmt"
"log/slog"
"os"
"time"
"github.com/chorus-services/backbeat/pkg/sdk"
"chorus/pkg/config"
)
// Integration manages CHORUS's integration with the BACKBEAT timing system
type Integration struct {
client sdk.Client
config *BackbeatConfig
logger Logger
ctx context.Context
cancel context.CancelFunc
started bool
nodeID string
// P2P operation tracking
activeOperations map[string]*P2POperation
}
// BackbeatConfig holds BACKBEAT-specific configuration
type BackbeatConfig struct {
Enabled bool
ClusterID string
AgentID string
NATSUrl string
}
// Logger interface for integration with CHORUS logging
type Logger interface {
Info(msg string, args ...interface{})
Warn(msg string, args ...interface{})
Error(msg string, args ...interface{})
}
// P2POperation tracks a P2P coordination operation's progress through BACKBEAT
type P2POperation struct {
ID string
Type string // "election", "dht_store", "pubsub_sync", "peer_discovery"
StartBeat int64
EstimatedBeats int
Phase OperationPhase
PeerCount int
StartTime time.Time
Data interface{}
}
// OperationPhase represents the current phase of a P2P operation
type OperationPhase int
const (
PhaseStarted OperationPhase = iota
PhaseConnecting
PhaseNegotiating
PhaseExecuting
PhaseCompleted
PhaseFailed
)
func (p OperationPhase) String() string {
switch p {
case PhaseStarted:
return "started"
case PhaseConnecting:
return "connecting"
case PhaseNegotiating:
return "negotiating"
case PhaseExecuting:
return "executing"
case PhaseCompleted:
return "completed"
case PhaseFailed:
return "failed"
default:
return "unknown"
}
}
// NewIntegration creates a new BACKBEAT integration for CHORUS
func NewIntegration(cfg *config.Config, nodeID string, logger Logger) (*Integration, error) {
backbeatCfg := extractBackbeatConfig(cfg)
if !backbeatCfg.Enabled {
return nil, fmt.Errorf("BACKBEAT integration is disabled")
}
// Create BACKBEAT SDK config with slog logger
sdkConfig := sdk.DefaultConfig()
sdkConfig.ClusterID = backbeatCfg.ClusterID
sdkConfig.AgentID = backbeatCfg.AgentID
sdkConfig.NATSUrl = backbeatCfg.NATSUrl
sdkConfig.Logger = slog.Default() // Use default slog logger
// Create SDK client
client := sdk.NewClient(sdkConfig)
return &Integration{
client: client,
config: backbeatCfg,
logger: logger,
nodeID: nodeID,
activeOperations: make(map[string]*P2POperation),
}, nil
}
// extractBackbeatConfig extracts BACKBEAT configuration from CHORUS config
func extractBackbeatConfig(cfg *config.Config) *BackbeatConfig {
return &BackbeatConfig{
Enabled: getEnvBool("CHORUS_BACKBEAT_ENABLED", true),
ClusterID: getEnv("CHORUS_BACKBEAT_CLUSTER_ID", "chorus-production"),
AgentID: getEnv("CHORUS_BACKBEAT_AGENT_ID", fmt.Sprintf("chorus-%s", cfg.Agent.ID)),
NATSUrl: getEnv("CHORUS_BACKBEAT_NATS_URL", "nats://backbeat-nats:4222"),
}
}
// Start initializes the BACKBEAT integration
func (i *Integration) Start(ctx context.Context) error {
if i.started {
return fmt.Errorf("integration already started")
}
i.ctx, i.cancel = context.WithCancel(ctx)
// Start the SDK client
if err := i.client.Start(i.ctx); err != nil {
return fmt.Errorf("failed to start BACKBEAT client: %w", err)
}
// Register beat callbacks
if err := i.client.OnBeat(i.onBeat); err != nil {
return fmt.Errorf("failed to register beat callback: %w", err)
}
if err := i.client.OnDownbeat(i.onDownbeat); err != nil {
return fmt.Errorf("failed to register downbeat callback: %w", err)
}
i.started = true
i.logger.Info("🎵 CHORUS BACKBEAT integration started - cluster=%s agent=%s",
i.config.ClusterID, i.config.AgentID)
return nil
}
// Stop gracefully shuts down the BACKBEAT integration
func (i *Integration) Stop() error {
if !i.started {
return nil
}
if i.cancel != nil {
i.cancel()
}
if err := i.client.Stop(); err != nil {
i.logger.Warn("⚠️ Error stopping BACKBEAT client: %v", err)
}
i.started = false
i.logger.Info("🎵 CHORUS BACKBEAT integration stopped")
return nil
}
// onBeat handles regular beat events from BACKBEAT
func (i *Integration) onBeat(beat sdk.BeatFrame) {
i.logger.Info("🥁 BACKBEAT beat received - beat=%d phase=%s tempo=%d window=%s",
beat.BeatIndex, beat.Phase, beat.TempoBPM, beat.WindowID)
// Emit status claim for active operations
for _, op := range i.activeOperations {
i.emitOperationStatus(op)
}
// Periodic health status emission
if beat.BeatIndex%8 == 0 { // Every 8 beats (4 minutes at 2 BPM)
i.emitHealthStatus()
}
}
// onDownbeat handles downbeat (bar start) events
func (i *Integration) onDownbeat(beat sdk.BeatFrame) {
i.logger.Info("🎼 BACKBEAT downbeat - new bar started - beat=%d window=%s",
beat.BeatIndex, beat.WindowID)
// Cleanup completed operations on downbeat
i.cleanupCompletedOperations()
}
// StartP2POperation registers a new P2P operation with BACKBEAT
func (i *Integration) StartP2POperation(operationID, operationType string, estimatedBeats int, data interface{}) error {
if !i.started {
return fmt.Errorf("BACKBEAT integration not started")
}
operation := &P2POperation{
ID: operationID,
Type: operationType,
StartBeat: i.client.GetCurrentBeat(),
EstimatedBeats: estimatedBeats,
Phase: PhaseStarted,
StartTime: time.Now(),
Data: data,
}
i.activeOperations[operationID] = operation
// Emit initial status claim
return i.emitOperationStatus(operation)
}
// UpdateP2POperationPhase updates the phase of an active P2P operation
func (i *Integration) UpdateP2POperationPhase(operationID string, phase OperationPhase, peerCount int) error {
operation, exists := i.activeOperations[operationID]
if !exists {
return fmt.Errorf("operation %s not found", operationID)
}
operation.Phase = phase
operation.PeerCount = peerCount
// Emit updated status claim
return i.emitOperationStatus(operation)
}
// CompleteP2POperation marks a P2P operation as completed
func (i *Integration) CompleteP2POperation(operationID string, peerCount int) error {
operation, exists := i.activeOperations[operationID]
if !exists {
return fmt.Errorf("operation %s not found", operationID)
}
operation.Phase = PhaseCompleted
operation.PeerCount = peerCount
// Emit completion status claim
if err := i.emitOperationStatus(operation); err != nil {
return err
}
// Remove from active operations
delete(i.activeOperations, operationID)
return nil
}
// FailP2POperation marks a P2P operation as failed
func (i *Integration) FailP2POperation(operationID string, reason string) error {
operation, exists := i.activeOperations[operationID]
if !exists {
return fmt.Errorf("operation %s not found", operationID)
}
operation.Phase = PhaseFailed
// Emit failure status claim
claim := sdk.StatusClaim{
State: "failed",
BeatsLeft: 0,
Progress: 0.0,
Notes: fmt.Sprintf("P2P operation failed: %s (type: %s)", reason, operation.Type),
}
if err := i.client.EmitStatusClaim(claim); err != nil {
return fmt.Errorf("failed to emit failure status: %w", err)
}
// Remove from active operations
delete(i.activeOperations, operationID)
return nil
}
// emitOperationStatus emits a status claim for a P2P operation
func (i *Integration) emitOperationStatus(operation *P2POperation) error {
currentBeat := i.client.GetCurrentBeat()
beatsPassed := currentBeat - operation.StartBeat
beatsLeft := operation.EstimatedBeats - int(beatsPassed)
if beatsLeft < 0 {
beatsLeft = 0
}
progress := float64(beatsPassed) / float64(operation.EstimatedBeats)
if progress > 1.0 {
progress = 1.0
}
state := "executing"
if operation.Phase == PhaseCompleted {
state = "done"
progress = 1.0
beatsLeft = 0
} else if operation.Phase == PhaseFailed {
state = "failed"
progress = 0.0
beatsLeft = 0
}
claim := sdk.StatusClaim{
TaskID: operation.ID,
State: state,
BeatsLeft: beatsLeft,
Progress: progress,
Notes: fmt.Sprintf("P2P %s: %s (peers: %d, node: %s)",
operation.Type, operation.Phase.String(), operation.PeerCount, i.nodeID),
}
return i.client.EmitStatusClaim(claim)
}
// emitHealthStatus emits a general health status claim
func (i *Integration) emitHealthStatus() error {
health := i.client.Health()
state := "waiting"
if len(i.activeOperations) > 0 {
state = "executing"
}
notes := fmt.Sprintf("CHORUS P2P healthy: connected=%v, operations=%d, tempo=%d BPM, node=%s",
health.Connected, len(i.activeOperations), health.CurrentTempo, i.nodeID)
if len(health.Errors) > 0 {
state = "failed"
notes += fmt.Sprintf(", errors: %d", len(health.Errors))
}
claim := sdk.StatusClaim{
TaskID: "chorus-p2p-health",
State: state,
BeatsLeft: 0,
Progress: 1.0,
Notes: notes,
}
return i.client.EmitStatusClaim(claim)
}
// cleanupCompletedOperations removes old completed operations
func (i *Integration) cleanupCompletedOperations() {
// This is called on downbeat, cleanup already happens in CompleteP2POperation/FailP2POperation
i.logger.Info("🧹 BACKBEAT operations cleanup check - active: %d", len(i.activeOperations))
}
// GetHealth returns the current BACKBEAT integration health
func (i *Integration) GetHealth() map[string]interface{} {
if !i.started {
return map[string]interface{}{
"enabled": i.config.Enabled,
"started": false,
"connected": false,
}
}
health := i.client.Health()
return map[string]interface{}{
"enabled": i.config.Enabled,
"started": i.started,
"connected": health.Connected,
"current_beat": health.LastBeat,
"current_tempo": health.CurrentTempo,
"measured_bpm": health.MeasuredBPM,
"tempo_drift": health.TempoDrift.String(),
"reconnect_count": health.ReconnectCount,
"active_operations": len(i.activeOperations),
"local_degradation": health.LocalDegradation,
"errors": health.Errors,
"node_id": i.nodeID,
}
}
// ExecuteWithBeatBudget executes a function with a BACKBEAT beat budget
func (i *Integration) ExecuteWithBeatBudget(beats int, fn func() error) error {
if !i.started {
return fn() // Fall back to regular execution if not started
}
return i.client.WithBeatBudget(beats, fn)
}
// Utility functions for environment variable handling
func getEnv(key, defaultValue string) string {
if value := os.Getenv(key); value != "" {
return value
}
return defaultValue
}
func getEnvBool(key string, defaultValue bool) bool {
value := os.Getenv(key)
if value == "" {
return defaultValue
}
return value == "true" || value == "1" || value == "yes" || value == "on"
}

34
internal/licensing/validator.go
View File

@@ -9,15 +9,15 @@ import (
) )
const ( const (
DefaultKachingURL = "https://kaching.chorus.services" DefaultKachingURL = "http://localhost:8083" // For development testing
LicenseTimeout = 30 * time.Second LicenseTimeout = 30 * time.Second
) )
// LicenseConfig holds licensing information // LicenseConfig holds licensing information
type LicenseConfig struct { type LicenseConfig struct {
Email string LicenseID string
LicenseKey string ClusterID string
ClusterID string KachingURL string
} }
// Validator handles license validation with KACHING // Validator handles license validation with KACHING
@@ -29,9 +29,14 @@ type Validator struct {
// NewValidator creates a new license validator // NewValidator creates a new license validator
func NewValidator(config LicenseConfig) *Validator { func NewValidator(config LicenseConfig) *Validator {
kachingURL := config.KachingURL
if kachingURL == "" {
kachingURL = DefaultKachingURL
}
return &Validator{ return &Validator{
config: config, config: config,
kachingURL: DefaultKachingURL, kachingURL: kachingURL,
client: &http.Client{ client: &http.Client{
Timeout: LicenseTimeout, Timeout: LicenseTimeout,
}, },
@@ -41,18 +46,19 @@ func NewValidator(config LicenseConfig) *Validator {
// Validate performs license validation with KACHING license authority // Validate performs license validation with KACHING license authority
// CRITICAL: CHORUS will not start without valid license validation // CRITICAL: CHORUS will not start without valid license validation
func (v *Validator) Validate() error { func (v *Validator) Validate() error {
if v.config.Email == "" || v.config.LicenseKey == "" { if v.config.LicenseID == "" || v.config.ClusterID == "" {
return fmt.Errorf("license email and key are required") return fmt.Errorf("license ID and cluster ID are required")
} }
// Prepare validation request // Prepare validation request
request := map[string]interface{}{ request := map[string]interface{}{
"email": v.config.Email, "license_id": v.config.LicenseID,
"license_key": v.config.LicenseKey, "cluster_id": v.config.ClusterID,
"cluster_id": v.config.ClusterID, "metadata": map[string]string{
"product": "CHORUS", "product": "CHORUS",
"version": "0.1.0-dev", "version": "0.1.0-dev",
"container": true, // Flag indicating this is a container deployment "container": "true",
},
} }
requestBody, err := json.Marshal(request) requestBody, err := json.Marshal(request)
@@ -61,7 +67,7 @@ func (v *Validator) Validate() error {
} }
// Call KACHING license authority // Call KACHING license authority
licenseURL := fmt.Sprintf("%s/v1/license/validate", v.kachingURL) licenseURL := fmt.Sprintf("%s/v1/license/activate", v.kachingURL)
resp, err := v.client.Post(licenseURL, "application/json", bytes.NewReader(requestBody)) resp, err := v.client.Post(licenseURL, "application/json", bytes.NewReader(requestBody))
if err != nil { if err != nil {
// FAIL-CLOSED: No network = No license = No operation // FAIL-CLOSED: No network = No license = No operation

210
internal/logging/logger.go
View File

@@ -1,210 +0,0 @@
package logging
import (
"encoding/json"
"fmt"
"os"
"time"
)
// Logger interface for CHORUS logging
type Logger interface {
Info(msg string, args ...interface{})
Warn(msg string, args ...interface{})
Error(msg string, args ...interface{})
Debug(msg string, args ...interface{})
}
// ContainerLogger provides structured logging optimized for container environments
// All logs go to stdout/stderr for collection by container runtime (Docker, K8s, etc.)
type ContainerLogger struct {
name string
level LogLevel
format LogFormat
}
// LogLevel represents logging levels
type LogLevel int
const (
DEBUG LogLevel = iota
INFO
WARN
ERROR
)
// LogFormat represents log output formats
type LogFormat int
const (
STRUCTURED LogFormat = iota // JSON structured logging
HUMAN // Human-readable logging
)
// LogEntry represents a structured log entry
type LogEntry struct {
Timestamp string `json:"timestamp"`
Level string `json:"level"`
Service string `json:"service"`
Message string `json:"message"`
Data map[string]interface{} `json:"data,omitempty"`
}
// NewContainerLogger creates a new container-optimized logger
func NewContainerLogger(serviceName string) *ContainerLogger {
level := INFO
format := STRUCTURED
// Parse log level from environment
if levelStr := os.Getenv("LOG_LEVEL"); levelStr != "" {
switch levelStr {
case "debug":
level = DEBUG
case "info":
level = INFO
case "warn":
level = WARN
case "error":
level = ERROR
}
}
// Parse log format from environment
if formatStr := os.Getenv("LOG_FORMAT"); formatStr == "human" {
format = HUMAN
}
return &ContainerLogger{
name: serviceName,
level: level,
format: format,
}
}
// Info logs informational messages
func (l *ContainerLogger) Info(msg string, args ...interface{}) {
if l.level <= INFO {
l.log(INFO, msg, args...)
}
}
// Warn logs warning messages
func (l *ContainerLogger) Warn(msg string, args ...interface{}) {
if l.level <= WARN {
l.log(WARN, msg, args...)
}
}
// Error logs error messages to stderr
func (l *ContainerLogger) Error(msg string, args ...interface{}) {
if l.level <= ERROR {
l.logToStderr(ERROR, msg, args...)
}
}
// Debug logs debug messages (only when DEBUG level is enabled)
func (l *ContainerLogger) Debug(msg string, args ...interface{}) {
if l.level <= DEBUG {
l.log(DEBUG, msg, args...)
}
}
// log writes log entries to stdout
func (l *ContainerLogger) log(level LogLevel, msg string, args ...interface{}) {
entry := l.createLogEntry(level, msg, args...)
switch l.format {
case STRUCTURED:
l.writeJSON(os.Stdout, entry)
case HUMAN:
l.writeHuman(os.Stdout, entry)
}
}
// logToStderr writes log entries to stderr (for errors)
func (l *ContainerLogger) logToStderr(level LogLevel, msg string, args ...interface{}) {
entry := l.createLogEntry(level, msg, args...)
switch l.format {
case STRUCTURED:
l.writeJSON(os.Stderr, entry)
case HUMAN:
l.writeHuman(os.Stderr, entry)
}
}
// createLogEntry creates a structured log entry
func (l *ContainerLogger) createLogEntry(level LogLevel, msg string, args ...interface{}) LogEntry {
return LogEntry{
Timestamp: time.Now().UTC().Format(time.RFC3339Nano),
Level: l.levelToString(level),
Service: l.name,
Message: fmt.Sprintf(msg, args...),
Data: make(map[string]interface{}),
}
}
// writeJSON writes the log entry as JSON
func (l *ContainerLogger) writeJSON(output *os.File, entry LogEntry) {
if jsonData, err := json.Marshal(entry); err == nil {
fmt.Fprintln(output, string(jsonData))
}
}
// writeHuman writes the log entry in human-readable format
func (l *ContainerLogger) writeHuman(output *os.File, entry LogEntry) {
fmt.Fprintf(output, "[%s] [%s] [%s] %s\n",
entry.Timestamp,
entry.Level,
entry.Service,
entry.Message,
)
}
// levelToString converts LogLevel to string
func (l *ContainerLogger) levelToString(level LogLevel) string {
switch level {
case DEBUG:
return "DEBUG"
case INFO:
return "INFO"
case WARN:
return "WARN"
case ERROR:
return "ERROR"
default:
return "UNKNOWN"
}
}
// WithData creates a logger that includes additional structured data in log entries
func (l *ContainerLogger) WithData(data map[string]interface{}) Logger {
// Return a new logger instance that includes the data
// This is useful for request-scoped logging with context
return &dataLogger{
base: l,
data: data,
}
}
// dataLogger is a wrapper that adds structured data to log entries
type dataLogger struct {
base Logger
data map[string]interface{}
}
func (d *dataLogger) Info(msg string, args ...interface{}) {
d.base.Info(msg, args...)
}
func (d *dataLogger) Warn(msg string, args ...interface{}) {
d.base.Warn(msg, args...)
}
func (d *dataLogger) Error(msg string, args ...interface{}) {
d.base.Error(msg, args...)
}
func (d *dataLogger) Debug(msg string, args ...interface{}) {
d.base.Debug(msg, args...)
}

8
p2p/config.go
View File

@@ -46,17 +46,17 @@ func DefaultConfig() *Config {
"/ip4/0.0.0.0/tcp/3333", "/ip4/0.0.0.0/tcp/3333",
"/ip6/::/tcp/3333", "/ip6/::/tcp/3333",
}, },
NetworkID: "bzzz-network", NetworkID: "CHORUS-network",
// Discovery settings // Discovery settings
EnableMDNS: true, EnableMDNS: true,
MDNSServiceTag: "bzzz-peer-discovery", MDNSServiceTag: "CHORUS-peer-discovery",
// DHT settings (disabled by default for local development) // DHT settings (disabled by default for local development)
EnableDHT: false, EnableDHT: false,
DHTBootstrapPeers: []string{}, DHTBootstrapPeers: []string{},
DHTMode: "auto", DHTMode: "auto",
DHTProtocolPrefix: "/bzzz", DHTProtocolPrefix: "/CHORUS",
// Connection limits for local network // Connection limits for local network
MaxConnections: 50, MaxConnections: 50,
@@ -68,7 +68,7 @@ func DefaultConfig() *Config {
// Pubsub for coordination and meta-discussion // Pubsub for coordination and meta-discussion
EnablePubsub: true, EnablePubsub: true,
BzzzTopic: "bzzz/coordination/v1", BzzzTopic: "CHORUS/coordination/v1",
HmmmTopic: "hmmm/meta-discussion/v1", HmmmTopic: "hmmm/meta-discussion/v1",
MessageValidationTime: 10 * time.Second, MessageValidationTime: 10 * time.Second,
} }

2
p2p/node.go
View File

@@ -5,7 +5,7 @@ import (
"fmt" "fmt"
"time" "time"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"github.com/libp2p/go-libp2p" "github.com/libp2p/go-libp2p"
"github.com/libp2p/go-libp2p/core/host" "github.com/libp2p/go-libp2p/core/host"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"

132
pkg/config/config.go
View File

@@ -2,25 +2,28 @@ package config
import ( import (
"fmt" "fmt"
"io/ioutil"
"os" "os"
"strconv" "strconv"
"strings" "strings"
"time" "time"
) )
// This is a container-adapted version of BZZZ's config system // This is a container-adapted version of CHORUS's config system
// All configuration comes from environment variables instead of YAML files // All configuration comes from environment variables instead of YAML files
// Config represents the complete CHORUS configuration loaded from environment variables // Config represents the complete CHORUS configuration loaded from environment variables
type Config struct { type Config struct {
Agent AgentConfig `yaml:"agent"` Agent AgentConfig `yaml:"agent"`
Network NetworkConfig `yaml:"network"` Network NetworkConfig `yaml:"network"`
License LicenseConfig `yaml:"license"` License LicenseConfig `yaml:"license"`
AI AIConfig `yaml:"ai"` AI AIConfig `yaml:"ai"`
Logging LoggingConfig `yaml:"logging"` Logging LoggingConfig `yaml:"logging"`
V2 V2Config `yaml:"v2"` V2 V2Config `yaml:"v2"`
UCXL UCXLConfig `yaml:"ucxl"` UCXL UCXLConfig `yaml:"ucxl"`
Slurp SlurpConfig `yaml:"slurp"` Slurp SlurpConfig `yaml:"slurp"`
Security SecurityConfig `yaml:"security"`
WHOOSHAPI WHOOSHAPIConfig `yaml:"whoosh_api"`
} }
// AgentConfig defines agent-specific settings // AgentConfig defines agent-specific settings
@@ -46,10 +49,9 @@ type NetworkConfig struct {
BindAddr string `yaml:"bind_address"` BindAddr string `yaml:"bind_address"`
} }
// LicenseConfig defines licensing settings (adapted from BZZZ) // LicenseConfig defines licensing settings (adapted from CHORUS)
type LicenseConfig struct { type LicenseConfig struct {
Email string `yaml:"email"` LicenseID string `yaml:"license_id"`
LicenseKey string `yaml:"license_key"`
ClusterID string `yaml:"cluster_id"` ClusterID string `yaml:"cluster_id"`
OrganizationName string `yaml:"organization_name"` OrganizationName string `yaml:"organization_name"`
KachingURL string `yaml:"kaching_url"` KachingURL string `yaml:"kaching_url"`
@@ -63,7 +65,9 @@ type LicenseConfig struct {
// AIConfig defines AI service settings // AIConfig defines AI service settings
type AIConfig struct { type AIConfig struct {
Ollama OllamaConfig `yaml:"ollama"` Provider string `yaml:"provider"`
Ollama OllamaConfig `yaml:"ollama"`
ResetData ResetDataConfig `yaml:"resetdata"`
} }
// OllamaConfig defines Ollama-specific settings // OllamaConfig defines Ollama-specific settings
@@ -72,13 +76,21 @@ type OllamaConfig struct {
Timeout time.Duration `yaml:"timeout"` Timeout time.Duration `yaml:"timeout"`
} }
// ResetDataConfig defines ResetData LLM service settings
type ResetDataConfig struct {
BaseURL string `yaml:"base_url"`
APIKey string `yaml:"api_key"`
Model string `yaml:"model"`
Timeout time.Duration `yaml:"timeout"`
}
// LoggingConfig defines logging settings // LoggingConfig defines logging settings
type LoggingConfig struct { type LoggingConfig struct {
Level string `yaml:"level"` Level string `yaml:"level"`
Format string `yaml:"format"` Format string `yaml:"format"`
} }
// V2Config defines v2-specific settings (from BZZZ) // V2Config defines v2-specific settings (from CHORUS)
type V2Config struct { type V2Config struct {
DHT DHTConfig `yaml:"dht"` DHT DHTConfig `yaml:"dht"`
} }
@@ -119,6 +131,14 @@ type SlurpConfig struct {
Enabled bool `yaml:"enabled"` Enabled bool `yaml:"enabled"`
} }
// WHOOSHAPIConfig defines WHOOSH API integration settings
type WHOOSHAPIConfig struct {
URL string `yaml:"url"`
BaseURL string `yaml:"base_url"`
Token string `yaml:"token"`
Enabled bool `yaml:"enabled"`
}
// LoadFromEnvironment loads configuration from environment variables // LoadFromEnvironment loads configuration from environment variables
func LoadFromEnvironment() (*Config, error) { func LoadFromEnvironment() (*Config, error) {
cfg := &Config{ cfg := &Config{
@@ -127,13 +147,13 @@ func LoadFromEnvironment() (*Config, error) {
Specialization: getEnvOrDefault("CHORUS_SPECIALIZATION", "general_developer"), Specialization: getEnvOrDefault("CHORUS_SPECIALIZATION", "general_developer"),
MaxTasks: getEnvIntOrDefault("CHORUS_MAX_TASKS", 3), MaxTasks: getEnvIntOrDefault("CHORUS_MAX_TASKS", 3),
Capabilities: getEnvArrayOrDefault("CHORUS_CAPABILITIES", []string{"general_development", "task_coordination"}), Capabilities: getEnvArrayOrDefault("CHORUS_CAPABILITIES", []string{"general_development", "task_coordination"}),
Models: getEnvArrayOrDefault("CHORUS_MODELS", []string{"llama3.1:8b"}), Models: getEnvArrayOrDefault("CHORUS_MODELS", []string{"meta/llama-3.1-8b-instruct"}),
Role: getEnvOrDefault("CHORUS_ROLE", ""), Role: getEnvOrDefault("CHORUS_ROLE", ""),
Expertise: getEnvArrayOrDefault("CHORUS_EXPERTISE", []string{}), Expertise: getEnvArrayOrDefault("CHORUS_EXPERTISE", []string{}),
ReportsTo: getEnvOrDefault("CHORUS_REPORTS_TO", ""), ReportsTo: getEnvOrDefault("CHORUS_REPORTS_TO", ""),
Deliverables: getEnvArrayOrDefault("CHORUS_DELIVERABLES", []string{}), Deliverables: getEnvArrayOrDefault("CHORUS_DELIVERABLES", []string{}),
ModelSelectionWebhook: getEnvOrDefault("CHORUS_MODEL_SELECTION_WEBHOOK", ""), ModelSelectionWebhook: getEnvOrDefault("CHORUS_MODEL_SELECTION_WEBHOOK", ""),
DefaultReasoningModel: getEnvOrDefault("CHORUS_DEFAULT_REASONING_MODEL", "llama3.1:8b"), DefaultReasoningModel: getEnvOrDefault("CHORUS_DEFAULT_REASONING_MODEL", "meta/llama-3.1-8b-instruct"),
}, },
Network: NetworkConfig{ Network: NetworkConfig{
P2PPort: getEnvIntOrDefault("CHORUS_P2P_PORT", 9000), P2PPort: getEnvIntOrDefault("CHORUS_P2P_PORT", 9000),
@@ -142,8 +162,7 @@ func LoadFromEnvironment() (*Config, error) {
BindAddr: getEnvOrDefault("CHORUS_BIND_ADDRESS", "0.0.0.0"), BindAddr: getEnvOrDefault("CHORUS_BIND_ADDRESS", "0.0.0.0"),
}, },
License: LicenseConfig{ License: LicenseConfig{
Email: os.Getenv("CHORUS_LICENSE_EMAIL"), LicenseID: getEnvOrFileContent("CHORUS_LICENSE_ID", "CHORUS_LICENSE_ID_FILE"),
LicenseKey: os.Getenv("CHORUS_LICENSE_KEY"),
ClusterID: getEnvOrDefault("CHORUS_CLUSTER_ID", "default-cluster"), ClusterID: getEnvOrDefault("CHORUS_CLUSTER_ID", "default-cluster"),
OrganizationName: getEnvOrDefault("CHORUS_ORGANIZATION_NAME", ""), OrganizationName: getEnvOrDefault("CHORUS_ORGANIZATION_NAME", ""),
KachingURL: getEnvOrDefault("CHORUS_KACHING_URL", "https://kaching.chorus.services"), KachingURL: getEnvOrDefault("CHORUS_KACHING_URL", "https://kaching.chorus.services"),
@@ -151,10 +170,17 @@ func LoadFromEnvironment() (*Config, error) {
GracePeriodHours: getEnvIntOrDefault("CHORUS_GRACE_PERIOD_HOURS", 72), GracePeriodHours: getEnvIntOrDefault("CHORUS_GRACE_PERIOD_HOURS", 72),
}, },
AI: AIConfig{ AI: AIConfig{
Provider: getEnvOrDefault("CHORUS_AI_PROVIDER", "resetdata"),
Ollama: OllamaConfig{ Ollama: OllamaConfig{
Endpoint: getEnvOrDefault("OLLAMA_ENDPOINT", "http://localhost:11434"), Endpoint: getEnvOrDefault("OLLAMA_ENDPOINT", "http://localhost:11434"),
Timeout: getEnvDurationOrDefault("OLLAMA_TIMEOUT", 30*time.Second), Timeout: getEnvDurationOrDefault("OLLAMA_TIMEOUT", 30*time.Second),
}, },
ResetData: ResetDataConfig{
BaseURL: getEnvOrDefault("RESETDATA_BASE_URL", "https://models.au-syd.resetdata.ai/v1"),
APIKey: os.Getenv("RESETDATA_API_KEY"),
Model: getEnvOrDefault("RESETDATA_MODEL", "meta/llama-3.1-8b-instruct"),
Timeout: getEnvDurationOrDefault("RESETDATA_TIMEOUT", 30*time.Second),
},
}, },
Logging: LoggingConfig{ Logging: LoggingConfig{
Level: getEnvOrDefault("LOG_LEVEL", "info"), Level: getEnvOrDefault("LOG_LEVEL", "info"),
@@ -183,6 +209,29 @@ func LoadFromEnvironment() (*Config, error) {
Slurp: SlurpConfig{ Slurp: SlurpConfig{
Enabled: getEnvBoolOrDefault("CHORUS_SLURP_ENABLED", false), Enabled: getEnvBoolOrDefault("CHORUS_SLURP_ENABLED", false),
}, },
Security: SecurityConfig{
KeyRotationDays: getEnvIntOrDefault("CHORUS_KEY_ROTATION_DAYS", 30),
AuditLogging: getEnvBoolOrDefault("CHORUS_AUDIT_LOGGING", true),
AuditPath: getEnvOrDefault("CHORUS_AUDIT_PATH", "/tmp/chorus-audit.log"),
ElectionConfig: ElectionConfig{
DiscoveryTimeout: getEnvDurationOrDefault("CHORUS_DISCOVERY_TIMEOUT", 10*time.Second),
HeartbeatTimeout: getEnvDurationOrDefault("CHORUS_HEARTBEAT_TIMEOUT", 30*time.Second),
ElectionTimeout: getEnvDurationOrDefault("CHORUS_ELECTION_TIMEOUT", 60*time.Second),
DiscoveryBackoff: getEnvDurationOrDefault("CHORUS_DISCOVERY_BACKOFF", 5*time.Second),
LeadershipScoring: &LeadershipScoring{
UptimeWeight: 0.4,
CapabilityWeight: 0.3,
ExperienceWeight: 0.2,
LoadWeight: 0.1,
},
},
},
WHOOSHAPI: WHOOSHAPIConfig{
URL: getEnvOrDefault("WHOOSH_API_URL", "http://localhost:3000"),
BaseURL: getEnvOrDefault("WHOOSH_API_BASE_URL", "http://localhost:3000"),
Token: os.Getenv("WHOOSH_API_TOKEN"),
Enabled: getEnvBoolOrDefault("WHOOSH_API_ENABLED", false),
},
} }
// Validate required configuration // Validate required configuration
@@ -195,12 +244,8 @@ func LoadFromEnvironment() (*Config, error) {
// Validate ensures all required configuration is present // Validate ensures all required configuration is present
func (c *Config) Validate() error { func (c *Config) Validate() error {
if c.License.Email == "" { if c.License.LicenseID == "" {
return fmt.Errorf("CHORUS_LICENSE_EMAIL is required") return fmt.Errorf("CHORUS_LICENSE_ID is required")
}
if c.License.LicenseKey == "" {
return fmt.Errorf("CHORUS_LICENSE_KEY is required")
} }
if c.Agent.ID == "" { if c.Agent.ID == "" {
@@ -217,16 +262,16 @@ func (c *Config) Validate() error {
return nil return nil
} }
// ApplyRoleDefinition applies role-based configuration (from BZZZ) // ApplyRoleDefinition applies role-based configuration (from CHORUS)
func (c *Config) ApplyRoleDefinition(role string) error { func (c *Config) ApplyRoleDefinition(role string) error {
// This would contain the role definition logic from BZZZ // This would contain the role definition logic from CHORUS
c.Agent.Role = role c.Agent.Role = role
return nil return nil
} }
// GetRoleAuthority returns the authority level for a role (from BZZZ) // GetRoleAuthority returns the authority level for a role (from CHORUS)
func (c *Config) GetRoleAuthority(role string) (string, error) { func (c *Config) GetRoleAuthority(role string) (string, error) {
// This would contain the authority mapping from BZZZ // This would contain the authority mapping from CHORUS
switch role { switch role {
case "admin": case "admin":
return "master", nil return "master", nil
@@ -278,6 +323,23 @@ func getEnvArrayOrDefault(key string, defaultValue []string) []string {
return defaultValue return defaultValue
} }
// getEnvOrFileContent reads from environment variable or file (for Docker secrets support)
func getEnvOrFileContent(envKey, fileEnvKey string) string {
// First try the direct environment variable
if value := os.Getenv(envKey); value != "" {
return value
}
// Then try reading from file path specified in fileEnvKey
if filePath := os.Getenv(fileEnvKey); filePath != "" {
if content, err := ioutil.ReadFile(filePath); err == nil {
return strings.TrimSpace(string(content))
}
}
return ""
}
// IsSetupRequired checks if setup is required (always false for containers) // IsSetupRequired checks if setup is required (always false for containers)
func IsSetupRequired(configPath string) bool { func IsSetupRequired(configPath string) bool {
return false // Containers are always pre-configured via environment return false // Containers are always pre-configured via environment
@@ -285,5 +347,17 @@ func IsSetupRequired(configPath string) bool {
// IsValidConfiguration validates configuration (simplified for containers) // IsValidConfiguration validates configuration (simplified for containers)
func IsValidConfiguration(cfg *Config) bool { func IsValidConfiguration(cfg *Config) bool {
return cfg.License.Email != "" && cfg.License.LicenseKey != "" return cfg.License.LicenseID != "" && cfg.License.ClusterID != ""
}
// LoadConfig loads configuration from file (for API compatibility)
func LoadConfig(configPath string) (*Config, error) {
// For containers, always load from environment
return LoadFromEnvironment()
}
// SaveConfig saves configuration to file (stub for API compatibility)
func SaveConfig(cfg *Config, configPath string) error {
// For containers, configuration is environment-based, so this is a no-op
return nil
} }

188
pkg/config/defaults.go
View File

@@ -1,188 +0,0 @@
package config
import (
"fmt"
"os"
"path/filepath"
"time"
)
// DefaultConfigPaths returns the default locations to search for config files
func DefaultConfigPaths() []string {
homeDir, _ := os.UserHomeDir()
return []string{
"./bzzz.yaml",
"./config/bzzz.yaml",
filepath.Join(homeDir, ".config", "bzzz", "config.yaml"),
"/etc/bzzz/config.yaml",
}
}
// GetNodeSpecificDefaults returns configuration defaults based on the node
func GetNodeSpecificDefaults(nodeID string) *Config {
config := getDefaultConfig()
// Set node-specific agent ID
config.Agent.ID = nodeID
// Set node-specific capabilities and models based on known cluster setup
switch {
case nodeID == "walnut" || containsString(nodeID, "walnut"):
config.Agent.Capabilities = []string{"task-coordination", "meta-discussion", "ollama-reasoning", "code-generation"}
config.Agent.Models = []string{"starcoder2:15b", "deepseek-coder-v2", "qwen3:14b", "phi3"}
config.Agent.Specialization = "code_generation"
case nodeID == "ironwood" || containsString(nodeID, "ironwood"):
config.Agent.Capabilities = []string{"task-coordination", "meta-discussion", "ollama-reasoning", "advanced-reasoning"}
config.Agent.Models = []string{"phi4:14b", "phi4-reasoning:14b", "gemma3:12b", "devstral"}
config.Agent.Specialization = "advanced_reasoning"
case nodeID == "acacia" || containsString(nodeID, "acacia"):
config.Agent.Capabilities = []string{"task-coordination", "meta-discussion", "ollama-reasoning", "code-analysis"}
config.Agent.Models = []string{"qwen2.5-coder", "deepseek-r1", "codellama", "llava"}
config.Agent.Specialization = "code_analysis"
default:
// Generic defaults for unknown nodes
config.Agent.Capabilities = []string{"task-coordination", "meta-discussion", "general"}
config.Agent.Models = []string{"phi3", "llama3.1"}
config.Agent.Specialization = "general_developer"
}
return config
}
// GetEnvironmentSpecificDefaults returns defaults based on environment
func GetEnvironmentSpecificDefaults(environment string) *Config {
config := getDefaultConfig()
switch environment {
case "development", "dev":
config.WHOOSHAPI.BaseURL = "http://localhost:8000"
config.P2P.EscalationWebhook = "http://localhost:5678/webhook-test/human-escalation"
config.Logging.Level = "debug"
config.Agent.PollInterval = 10 * time.Second
case "staging":
config.WHOOSHAPI.BaseURL = "https://hive-staging.home.deepblack.cloud"
config.P2P.EscalationWebhook = "https://n8n-staging.home.deepblack.cloud/webhook-test/human-escalation"
config.Logging.Level = "info"
config.Agent.PollInterval = 20 * time.Second
case "production", "prod":
config.WHOOSHAPI.BaseURL = "https://hive.home.deepblack.cloud"
config.P2P.EscalationWebhook = "https://n8n.home.deepblack.cloud/webhook-test/human-escalation"
config.Logging.Level = "warn"
config.Agent.PollInterval = 30 * time.Second
default:
// Default to production-like settings
config.Logging.Level = "info"
}
return config
}
// GetCapabilityPresets returns predefined capability sets
func GetCapabilityPresets() map[string][]string {
return map[string][]string{
"senior_developer": {
"task-coordination",
"meta-discussion",
"ollama-reasoning",
"code-generation",
"code-review",
"architecture",
},
"code_reviewer": {
"task-coordination",
"meta-discussion",
"ollama-reasoning",
"code-review",
"security-analysis",
"best-practices",
},
"debugger_specialist": {
"task-coordination",
"meta-discussion",
"ollama-reasoning",
"debugging",
"error-analysis",
"troubleshooting",
},
"devops_engineer": {
"task-coordination",
"meta-discussion",
"deployment",
"infrastructure",
"monitoring",
"automation",
},
"test_engineer": {
"task-coordination",
"meta-discussion",
"testing",
"quality-assurance",
"test-automation",
"validation",
},
"general_developer": {
"task-coordination",
"meta-discussion",
"ollama-reasoning",
"general",
},
}
}
// ApplyCapabilityPreset applies a predefined capability preset to the config
func (c *Config) ApplyCapabilityPreset(presetName string) error {
presets := GetCapabilityPresets()
capabilities, exists := presets[presetName]
if !exists {
return fmt.Errorf("unknown capability preset: %s", presetName)
}
c.Agent.Capabilities = capabilities
c.Agent.Specialization = presetName
return nil
}
// GetModelPresets returns predefined model sets for different specializations
func GetModelPresets() map[string][]string {
return map[string][]string{
"code_generation": {
"starcoder2:15b",
"deepseek-coder-v2",
"codellama",
},
"advanced_reasoning": {
"phi4:14b",
"phi4-reasoning:14b",
"deepseek-r1",
},
"code_analysis": {
"qwen2.5-coder",
"deepseek-coder-v2",
"codellama",
},
"general_purpose": {
"phi3",
"llama3.1:8b",
"qwen3",
},
"vision_tasks": {
"llava",
"llava:13b",
},
}
}
// containsString checks if a string contains a substring (case-insensitive)
func containsString(s, substr string) bool {
return len(s) >= len(substr) &&
(s[:len(substr)] == substr || s[len(s)-len(substr):] == substr)
}

4
pkg/config/hybrid_config.go
View File

@@ -44,7 +44,7 @@ type DiscoveryConfig struct {
MDNSEnabled bool `env:"BZZZ_MDNS_ENABLED" default:"true" json:"mdns_enabled" yaml:"mdns_enabled"` MDNSEnabled bool `env:"BZZZ_MDNS_ENABLED" default:"true" json:"mdns_enabled" yaml:"mdns_enabled"`
DHTDiscovery bool `env:"BZZZ_DHT_DISCOVERY" default:"false" json:"dht_discovery" yaml:"dht_discovery"` DHTDiscovery bool `env:"BZZZ_DHT_DISCOVERY" default:"false" json:"dht_discovery" yaml:"dht_discovery"`
AnnounceInterval time.Duration `env:"BZZZ_ANNOUNCE_INTERVAL" default:"30s" json:"announce_interval" yaml:"announce_interval"` AnnounceInterval time.Duration `env:"BZZZ_ANNOUNCE_INTERVAL" default:"30s" json:"announce_interval" yaml:"announce_interval"`
ServiceName string `env:"BZZZ_SERVICE_NAME" default:"bzzz" json:"service_name" yaml:"service_name"` ServiceName string `env:"BZZZ_SERVICE_NAME" default:"CHORUS" json:"service_name" yaml:"service_name"`
} }
type MonitoringConfig struct { type MonitoringConfig struct {
@@ -82,7 +82,7 @@ func LoadHybridConfig() (*HybridConfig, error) {
MDNSEnabled: getEnvBool("BZZZ_MDNS_ENABLED", true), MDNSEnabled: getEnvBool("BZZZ_MDNS_ENABLED", true),
DHTDiscovery: getEnvBool("BZZZ_DHT_DISCOVERY", false), DHTDiscovery: getEnvBool("BZZZ_DHT_DISCOVERY", false),
AnnounceInterval: getEnvDuration("BZZZ_ANNOUNCE_INTERVAL", 30*time.Second), AnnounceInterval: getEnvDuration("BZZZ_ANNOUNCE_INTERVAL", 30*time.Second),
ServiceName: getEnvString("BZZZ_SERVICE_NAME", "bzzz"), ServiceName: getEnvString("BZZZ_SERVICE_NAME", "CHORUS"),
} }
// Load Monitoring configuration // Load Monitoring configuration

573
pkg/config/roles.go
View File

@@ -1,573 +0,0 @@
package config
import (
"fmt"
"strings"
"time"
)
// AuthorityLevel defines the decision-making authority of a role
type AuthorityLevel string
const (
AuthorityMaster AuthorityLevel = "master" // Full admin access, can decrypt all roles (SLURP functionality)
AuthorityDecision AuthorityLevel = "decision" // Can make permanent decisions
AuthorityCoordination AuthorityLevel = "coordination" // Can coordinate across roles
AuthoritySuggestion AuthorityLevel = "suggestion" // Can suggest, no permanent decisions
AuthorityReadOnly AuthorityLevel = "read_only" // Observer access only
)
// AgeKeyPair holds Age encryption keys for a role
type AgeKeyPair struct {
PublicKey string `yaml:"public,omitempty" json:"public,omitempty"`
PrivateKey string `yaml:"private,omitempty" json:"private,omitempty"`
}
// ShamirShare represents a share of the admin secret key
type ShamirShare struct {
Index int `yaml:"index" json:"index"`
Share string `yaml:"share" json:"share"`
Threshold int `yaml:"threshold" json:"threshold"`
TotalShares int `yaml:"total_shares" json:"total_shares"`
}
// ElectionConfig defines consensus election parameters
type ElectionConfig struct {
// Trigger timeouts
HeartbeatTimeout time.Duration `yaml:"heartbeat_timeout" json:"heartbeat_timeout"`
DiscoveryTimeout time.Duration `yaml:"discovery_timeout" json:"discovery_timeout"`
ElectionTimeout time.Duration `yaml:"election_timeout" json:"election_timeout"`
// Discovery settings
MaxDiscoveryAttempts int `yaml:"max_discovery_attempts" json:"max_discovery_attempts"`
DiscoveryBackoff time.Duration `yaml:"discovery_backoff" json:"discovery_backoff"`
// Consensus requirements
MinimumQuorum int `yaml:"minimum_quorum" json:"minimum_quorum"`
ConsensusAlgorithm string `yaml:"consensus_algorithm" json:"consensus_algorithm"` // "raft", "pbft"
// Split brain detection
SplitBrainDetection bool `yaml:"split_brain_detection" json:"split_brain_detection"`
ConflictResolution string `yaml:"conflict_resolution,omitempty" json:"conflict_resolution,omitempty"`
}
// RoleDefinition represents a complete role definition with authority and encryption
type RoleDefinition struct {
// Existing fields from Bees-AgenticWorkers
Name string `yaml:"name"`
SystemPrompt string `yaml:"system_prompt"`
ReportsTo []string `yaml:"reports_to"`
Expertise []string `yaml:"expertise"`
Deliverables []string `yaml:"deliverables"`
Capabilities []string `yaml:"capabilities"`
// Collaboration preferences
CollaborationDefaults CollaborationConfig `yaml:"collaboration_defaults"`
// NEW: Authority and encryption fields for Phase 2A
AuthorityLevel AuthorityLevel `yaml:"authority_level" json:"authority_level"`
CanDecrypt []string `yaml:"can_decrypt,omitempty" json:"can_decrypt,omitempty"` // Roles this role can decrypt
AgeKeys AgeKeyPair `yaml:"age_keys,omitempty" json:"age_keys,omitempty"`
PromptTemplate string `yaml:"prompt_template,omitempty" json:"prompt_template,omitempty"`
Model string `yaml:"model,omitempty" json:"model,omitempty"`
MaxTasks int `yaml:"max_tasks,omitempty" json:"max_tasks,omitempty"`
// Special functions (for admin/specialized roles)
SpecialFunctions []string `yaml:"special_functions,omitempty" json:"special_functions,omitempty"`
// Decision context
DecisionScope []string `yaml:"decision_scope,omitempty" json:"decision_scope,omitempty"` // What domains this role can decide on
}
// GetPredefinedRoles returns all predefined roles from Bees-AgenticWorkers.md
func GetPredefinedRoles() map[string]RoleDefinition {
return map[string]RoleDefinition{
// NEW: Admin role with SLURP functionality
"admin": {
Name: "SLURP Admin Agent",
SystemPrompt: "You are the **SLURP Admin Agent** with master authority level and context curation functionality.\n\n* **Responsibilities:** Maintain global context graph, ingest and analyze all distributed decisions, manage key reconstruction, coordinate admin elections.\n* **Authority:** Can decrypt and analyze all role-encrypted decisions, publish system-level decisions, manage cluster security.\n* **Special Functions:** Context curation, decision ingestion, semantic analysis, key reconstruction, admin election coordination.\n* **Reports To:** Distributed consensus (no single authority).\n* **Deliverables:** Global context analysis, decision quality metrics, cluster health reports, security audit logs.",
ReportsTo: []string{}, // Admin reports to consensus
Expertise: []string{"context_curation", "decision_analysis", "semantic_indexing", "distributed_systems", "security", "consensus_algorithms"},
Deliverables: []string{"global_context_graph", "decision_quality_metrics", "cluster_health_reports", "security_audit_logs"},
Capabilities: []string{"context_curation", "decision_ingestion", "semantic_analysis", "key_reconstruction", "admin_election", "cluster_coordination"},
AuthorityLevel: AuthorityMaster,
CanDecrypt: []string{"*"}, // Can decrypt all roles
SpecialFunctions: []string{"slurp_functionality", "admin_election", "key_management", "consensus_coordination"},
Model: "gpt-4o",
MaxTasks: 10,
DecisionScope: []string{"system", "security", "architecture", "operations", "consensus"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"admin_election", "key_reconstruction", "consensus_request", "system_alert"},
AutoSubscribeToRoles: []string{"senior_software_architect", "security_expert", "systems_engineer"},
AutoSubscribeToExpertise: []string{"architecture", "security", "infrastructure", "consensus"},
ResponseTimeoutSeconds: 60, // Fast response for admin duties
MaxCollaborationDepth: 10,
EscalationThreshold: 1, // Immediate escalation for admin issues
},
},
"senior_software_architect": {
Name: "Senior Software Architect",
SystemPrompt: "You are the **Senior Software Architect**. You define the system's overall structure, select tech stacks, and ensure long-term maintainability.\n\n* **Responsibilities:** Draft high-level architecture diagrams, define API contracts, set coding standards, mentor engineering leads.\n* **Authority:** Can make strategic technical decisions that are published as permanent UCXL decision nodes.\n* **Expertise:** Deep experience in multiple programming paradigms, distributed systems, security models, and cloud architectures.\n* **Reports To:** Product Owner / Technical Director.\n* **Deliverables:** Architecture blueprints, tech stack decisions, integration strategies, and review sign-offs on major design changes.",
ReportsTo: []string{"product_owner", "technical_director", "admin"},
Expertise: []string{"architecture", "distributed_systems", "security", "cloud_architectures", "api_design"},
Deliverables: []string{"architecture_blueprints", "tech_stack_decisions", "integration_strategies", "design_reviews"},
Capabilities: []string{"task-coordination", "meta-discussion", "architecture", "code-review", "mentoring"},
AuthorityLevel: AuthorityDecision,
CanDecrypt: []string{"senior_software_architect", "backend_developer", "frontend_developer", "full_stack_engineer", "database_engineer"},
Model: "gpt-4o",
MaxTasks: 5,
DecisionScope: []string{"architecture", "design", "technology_selection", "system_integration"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"coordination_request", "meta_discussion", "escalation_trigger"},
AutoSubscribeToRoles: []string{"lead_designer", "security_expert", "systems_engineer"},
AutoSubscribeToExpertise: []string{"architecture", "security", "infrastructure"},
ResponseTimeoutSeconds: 300,
MaxCollaborationDepth: 5,
EscalationThreshold: 3,
},
},
"lead_designer": {
Name: "Lead Designer",
SystemPrompt: "You are the **Lead Designer**. You guide the creative vision and maintain design cohesion across the product.\n\n* **Responsibilities:** Oversee UX flow, wireframes, and feature design; ensure consistency of theme and style; mediate between product vision and technical constraints.\n* **Authority:** Can make design decisions that influence product direction and user experience.\n* **Expertise:** UI/UX principles, accessibility, information architecture, Figma/Sketch proficiency.\n* **Reports To:** Product Owner.\n* **Deliverables:** Style guides, wireframes, feature specs, and iterative design documentation.",
ReportsTo: []string{"product_owner", "admin"},
Expertise: []string{"ui_ux", "accessibility", "information_architecture", "design_systems", "user_research"},
Deliverables: []string{"style_guides", "wireframes", "feature_specs", "design_documentation"},
Capabilities: []string{"task-coordination", "meta-discussion", "design", "user_experience"},
AuthorityLevel: AuthorityDecision,
CanDecrypt: []string{"lead_designer", "ui_ux_designer", "frontend_developer"},
Model: "gpt-4o",
MaxTasks: 4,
DecisionScope: []string{"design", "user_experience", "accessibility", "visual_identity"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "coordination_request", "meta_discussion"},
AutoSubscribeToRoles: []string{"ui_ux_designer", "frontend_developer"},
AutoSubscribeToExpertise: []string{"design", "frontend", "user_experience"},
ResponseTimeoutSeconds: 180,
MaxCollaborationDepth: 3,
EscalationThreshold: 2,
},
},
"security_expert": {
Name: "Security Expert",
SystemPrompt: "You are the **Security Expert**. You ensure the system is hardened against vulnerabilities.\n\n* **Responsibilities:** Conduct threat modeling, penetration tests, code reviews for security flaws, and define access control policies.\n* **Authority:** Can make security-related decisions and coordinate security implementations across teams.\n* **Expertise:** Cybersecurity frameworks (OWASP, NIST), encryption, key management, zero-trust systems.\n* **Reports To:** Senior Software Architect.\n* **Deliverables:** Security audits, vulnerability reports, risk mitigation plans, compliance documentation.",
ReportsTo: []string{"senior_software_architect", "admin"},
Expertise: []string{"cybersecurity", "owasp", "nist", "encryption", "key_management", "zero_trust", "penetration_testing"},
Deliverables: []string{"security_audits", "vulnerability_reports", "risk_mitigation_plans", "compliance_documentation"},
Capabilities: []string{"task-coordination", "meta-discussion", "security-analysis", "code-review", "threat-modeling"},
AuthorityLevel: AuthorityCoordination,
CanDecrypt: []string{"security_expert", "backend_developer", "devops_engineer", "systems_engineer"},
Model: "gpt-4o",
MaxTasks: 4,
DecisionScope: []string{"security", "access_control", "threat_mitigation", "compliance"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"dependency_alert", "task_help_request", "escalation_trigger"},
AutoSubscribeToRoles: []string{"backend_developer", "devops_engineer", "senior_software_architect"},
AutoSubscribeToExpertise: []string{"security", "backend", "infrastructure"},
ResponseTimeoutSeconds: 120,
MaxCollaborationDepth: 4,
EscalationThreshold: 1,
},
},
"systems_engineer": {
Name: "Systems Engineer",
SystemPrompt: "You are the **Systems Engineer**. You connect hardware, operating systems, and software infrastructure.\n\n* **Responsibilities:** Configure OS environments, network setups, and middleware; ensure system performance and uptime.\n* **Expertise:** Linux/Unix systems, networking, hardware integration, automation tools.\n* **Reports To:** Technical Lead.\n* **Deliverables:** Infrastructure configurations, system diagrams, performance benchmarks.",
ReportsTo: []string{"technical_lead"},
Expertise: []string{"linux", "unix", "networking", "hardware_integration", "automation", "system_administration"},
Deliverables: []string{"infrastructure_configurations", "system_diagrams", "performance_benchmarks"},
Capabilities: []string{"task-coordination", "meta-discussion", "infrastructure", "system_administration", "automation"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"coordination_request", "dependency_alert", "task_help_request"},
AutoSubscribeToRoles: []string{"devops_engineer", "backend_developer"},
AutoSubscribeToExpertise: []string{"infrastructure", "deployment", "monitoring"},
ResponseTimeoutSeconds: 240,
MaxCollaborationDepth: 3,
EscalationThreshold: 2,
},
},
"frontend_developer": {
Name: "Frontend Developer",
SystemPrompt: "You are the **Frontend Developer**. You turn designs into interactive interfaces.\n\n* **Responsibilities:** Build UI components, optimize performance, ensure cross-browser/device compatibility, and integrate frontend with backend APIs.\n* **Expertise:** HTML, CSS, JavaScript/TypeScript, React/Vue/Angular, accessibility standards.\n* **Reports To:** Frontend Lead or Senior Architect.\n* **Deliverables:** Functional UI screens, reusable components, and documented frontend code.",
ReportsTo: []string{"frontend_lead", "senior_software_architect"},
Expertise: []string{"html", "css", "javascript", "typescript", "react", "vue", "angular", "accessibility"},
Deliverables: []string{"ui_screens", "reusable_components", "frontend_code", "documentation"},
Capabilities: []string{"task-coordination", "meta-discussion", "frontend", "ui_development", "component_design"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "coordination_request", "task_help_response"},
AutoSubscribeToRoles: []string{"ui_ux_designer", "backend_developer", "lead_designer"},
AutoSubscribeToExpertise: []string{"design", "backend", "api_integration"},
ResponseTimeoutSeconds: 180,
MaxCollaborationDepth: 3,
EscalationThreshold: 2,
},
},
"backend_developer": {
Name: "Backend Developer",
SystemPrompt: "You are the **Backend Developer**. You create APIs, logic, and server-side integrations.\n\n* **Responsibilities:** Implement core logic, manage data pipelines, enforce security, and support scaling strategies.\n* **Expertise:** Server frameworks, REST/GraphQL APIs, authentication, caching, microservices.\n* **Reports To:** Backend Lead or Senior Architect.\n* **Deliverables:** API endpoints, backend services, unit tests, and deployment-ready server code.",
ReportsTo: []string{"backend_lead", "senior_software_architect"},
Expertise: []string{"server_frameworks", "rest_api", "graphql", "authentication", "caching", "microservices", "databases"},
Deliverables: []string{"api_endpoints", "backend_services", "unit_tests", "server_code"},
Capabilities: []string{"task-coordination", "meta-discussion", "backend", "api_development", "database_design"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "coordination_request", "dependency_alert"},
AutoSubscribeToRoles: []string{"database_engineer", "frontend_developer", "security_expert"},
AutoSubscribeToExpertise: []string{"database", "frontend", "security"},
ResponseTimeoutSeconds: 200,
MaxCollaborationDepth: 4,
EscalationThreshold: 2,
},
},
"qa_engineer": {
Name: "QA Engineer",
SystemPrompt: "You are the **QA Engineer**. You ensure the system is reliable and bug-free.\n\n* **Responsibilities:** Create test plans, execute manual and automated tests, document bugs, and verify fixes.\n* **Expertise:** QA methodologies, Selenium/Cypress, regression testing, performance testing.\n* **Reports To:** QA Lead.\n* **Deliverables:** Test scripts, bug reports, QA coverage metrics, and sign-off on release quality.",
ReportsTo: []string{"qa_lead"},
Expertise: []string{"qa_methodologies", "selenium", "cypress", "regression_testing", "performance_testing", "test_automation"},
Deliverables: []string{"test_scripts", "bug_reports", "qa_metrics", "release_signoff"},
Capabilities: []string{"task-coordination", "meta-discussion", "testing", "quality_assurance", "test_automation"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "dependency_alert", "coordination_complete"},
AutoSubscribeToRoles: []string{"frontend_developer", "backend_developer", "devops_engineer"},
AutoSubscribeToExpertise: []string{"testing", "deployment", "automation"},
ResponseTimeoutSeconds: 150,
MaxCollaborationDepth: 3,
EscalationThreshold: 2,
},
},
"ui_ux_designer": {
Name: "UI/UX Designer",
SystemPrompt: "You are the **UI/UX Designer**. You shape how users interact with the product.\n\n* **Responsibilities:** Produce wireframes, prototypes, and design systems; ensure user flows are intuitive.\n* **Expertise:** Human-computer interaction, usability testing, Figma/Sketch, accessibility.\n* **Reports To:** Lead Designer.\n* **Deliverables:** Interactive prototypes, annotated mockups, and updated design documentation.",
ReportsTo: []string{"lead_designer"},
Expertise: []string{"human_computer_interaction", "usability_testing", "figma", "sketch", "accessibility", "user_flows"},
Deliverables: []string{"interactive_prototypes", "annotated_mockups", "design_documentation"},
Capabilities: []string{"task-coordination", "meta-discussion", "design", "prototyping", "user_research"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "coordination_request", "meta_discussion"},
AutoSubscribeToRoles: []string{"frontend_developer", "lead_designer"},
AutoSubscribeToExpertise: []string{"frontend", "design", "user_experience"},
ResponseTimeoutSeconds: 180,
MaxCollaborationDepth: 3,
EscalationThreshold: 2,
},
},
"ml_engineer": {
Name: "ML Engineer",
SystemPrompt: "You are the **Machine Learning Engineer**. You design, train, and integrate AI models into the product.\n\n* **Responsibilities:** Build pipelines, preprocess data, evaluate models, and deploy ML solutions.\n* **Expertise:** Python, TensorFlow/PyTorch, data engineering, model optimization.\n* **Reports To:** Senior Software Architect or Product Owner (depending on AI strategy).\n* **Deliverables:** Trained models, inference APIs, documentation of datasets and performance metrics.",
ReportsTo: []string{"senior_software_architect", "product_owner"},
Expertise: []string{"python", "tensorflow", "pytorch", "data_engineering", "model_optimization", "machine_learning"},
Deliverables: []string{"trained_models", "inference_apis", "dataset_documentation", "performance_metrics"},
Capabilities: []string{"task-coordination", "meta-discussion", "machine_learning", "data_analysis", "model_deployment"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "coordination_request", "meta_discussion"},
AutoSubscribeToRoles: []string{"backend_developer", "database_engineer", "devops_engineer"},
AutoSubscribeToExpertise: []string{"backend", "database", "deployment"},
ResponseTimeoutSeconds: 300,
MaxCollaborationDepth: 4,
EscalationThreshold: 3,
},
},
"devops_engineer": {
Name: "DevOps Engineer",
SystemPrompt: "You are the **DevOps Engineer**. You automate and maintain build, deployment, and monitoring systems.\n\n* **Responsibilities:** Manage CI/CD pipelines, infrastructure as code, observability, and rollback strategies.\n* **Expertise:** Docker, Kubernetes, Terraform, GitHub Actions/Jenkins, cloud providers.\n* **Reports To:** Systems Engineer or Senior Architect.\n* **Deliverables:** CI/CD configurations, monitoring dashboards, and operational runbooks.",
ReportsTo: []string{"systems_engineer", "senior_software_architect"},
Expertise: []string{"docker", "kubernetes", "terraform", "cicd", "github_actions", "jenkins", "cloud_providers", "monitoring"},
Deliverables: []string{"cicd_configurations", "monitoring_dashboards", "operational_runbooks"},
Capabilities: []string{"task-coordination", "meta-discussion", "deployment", "automation", "monitoring", "infrastructure"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"coordination_request", "dependency_alert", "task_help_request"},
AutoSubscribeToRoles: []string{"backend_developer", "systems_engineer", "security_expert"},
AutoSubscribeToExpertise: []string{"backend", "infrastructure", "security"},
ResponseTimeoutSeconds: 240,
MaxCollaborationDepth: 4,
EscalationThreshold: 2,
},
},
"specialist_3d": {
Name: "3D Specialist",
SystemPrompt: "You are the **3D Specialist**. You create and optimize 3D assets for the product.\n\n* **Responsibilities:** Model, texture, and rig characters, environments, and props; ensure performance-friendly assets.\n* **Expertise:** Blender, Maya, Substance Painter, Unity/Unreal pipelines, optimization techniques.\n* **Reports To:** Art Director or Lead Designer.\n* **Deliverables:** Game-ready 3D assets, texture packs, rigged models, and export guidelines.",
ReportsTo: []string{"art_director", "lead_designer"},
Expertise: []string{"blender", "maya", "substance_painter", "unity", "unreal", "3d_modeling", "texturing", "rigging"},
Deliverables: []string{"3d_assets", "texture_packs", "rigged_models", "export_guidelines"},
Capabilities: []string{"task-coordination", "meta-discussion", "3d_modeling", "asset_optimization"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "coordination_request", "meta_discussion"},
AutoSubscribeToRoles: []string{"lead_designer", "engine_programmer"},
AutoSubscribeToExpertise: []string{"design", "engine", "optimization"},
ResponseTimeoutSeconds: 300,
MaxCollaborationDepth: 3,
EscalationThreshold: 2,
},
},
"technical_writer": {
Name: "Technical Writer",
SystemPrompt: "You are the **Technical Writer**. You make sure all documentation is accurate and user-friendly.\n\n* **Responsibilities:** Write developer docs, API references, user manuals, and release notes.\n* **Expertise:** Strong writing skills, Markdown, diagramming, understanding of tech stacks.\n* **Reports To:** Product Owner or Project Manager.\n* **Deliverables:** User guides, developer onboarding docs, and API documentation.",
ReportsTo: []string{"product_owner", "project_manager"},
Expertise: []string{"technical_writing", "markdown", "diagramming", "documentation", "user_guides"},
Deliverables: []string{"user_guides", "developer_docs", "api_documentation", "release_notes"},
Capabilities: []string{"task-coordination", "meta-discussion", "documentation", "technical_writing"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "coordination_complete", "meta_discussion"},
AutoSubscribeToRoles: []string{"backend_developer", "frontend_developer", "senior_software_architect"},
AutoSubscribeToExpertise: []string{"api_design", "documentation", "architecture"},
ResponseTimeoutSeconds: 200,
MaxCollaborationDepth: 3,
EscalationThreshold: 2,
},
},
"full_stack_engineer": {
Name: "Full Stack Engineer",
SystemPrompt: "You are the **Full Stack Engineer**. You bridge frontend and backend to build complete features.\n\n* **Responsibilities:** Implement end-to-end features, debug across the stack, and assist in both client and server layers.\n* **Expertise:** Modern JS frameworks, backend APIs, databases, cloud deployment.\n* **Reports To:** Senior Architect or Tech Lead.\n* **Deliverables:** Full feature implementations, integration tests, and code linking UI to backend.",
ReportsTo: []string{"senior_software_architect", "tech_lead"},
Expertise: []string{"javascript", "frontend_frameworks", "backend_apis", "databases", "cloud_deployment", "full_stack"},
Deliverables: []string{"feature_implementations", "integration_tests", "end_to_end_code"},
Capabilities: []string{"task-coordination", "meta-discussion", "frontend", "backend", "full_stack_development"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "coordination_request", "task_help_response"},
AutoSubscribeToRoles: []string{"frontend_developer", "backend_developer", "database_engineer"},
AutoSubscribeToExpertise: []string{"frontend", "backend", "database"},
ResponseTimeoutSeconds: 200,
MaxCollaborationDepth: 4,
EscalationThreshold: 2,
},
},
"database_engineer": {
Name: "Database Engineer",
SystemPrompt: "You are the **Database Engineer**. You design and maintain data structures for performance and reliability.\n\n* **Responsibilities:** Design schemas, optimize queries, manage migrations, and implement backup strategies.\n* **Expertise:** SQL/NoSQL databases, indexing, query tuning, replication/sharding.\n* **Reports To:** Backend Lead or Senior Architect.\n* **Deliverables:** Schema diagrams, migration scripts, tuning reports, and disaster recovery plans.",
ReportsTo: []string{"backend_lead", "senior_software_architect"},
Expertise: []string{"sql", "nosql", "indexing", "query_tuning", "replication", "sharding", "database_design"},
Deliverables: []string{"schema_diagrams", "migration_scripts", "tuning_reports", "disaster_recovery_plans"},
Capabilities: []string{"task-coordination", "meta-discussion", "database_design", "query_optimization", "data_modeling"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "dependency_alert", "coordination_request"},
AutoSubscribeToRoles: []string{"backend_developer", "ml_engineer", "devops_engineer"},
AutoSubscribeToExpertise: []string{"backend", "machine_learning", "deployment"},
ResponseTimeoutSeconds: 240,
MaxCollaborationDepth: 3,
EscalationThreshold: 2,
},
},
"engine_programmer": {
Name: "Engine Programmer",
SystemPrompt: "You are the **Engine Programmer**. You work close to the metal to extend and optimize the engine.\n\n* **Responsibilities:** Develop low-level systems (rendering, physics, memory), maintain performance, and enable tools for designers/artists.\n* **Expertise:** C++/Rust, graphics APIs (Vulkan/DirectX/OpenGL), performance profiling, game/real-time engines.\n* **Reports To:** Senior Software Architect or Technical Director.\n* **Deliverables:** Engine modules, profiling reports, performance patches, and technical documentation.",
ReportsTo: []string{"senior_software_architect", "technical_director"},
Expertise: []string{"cpp", "rust", "vulkan", "directx", "opengl", "performance_profiling", "game_engines", "low_level_programming"},
Deliverables: []string{"engine_modules", "profiling_reports", "performance_patches", "technical_documentation"},
Capabilities: []string{"task-coordination", "meta-discussion", "engine_development", "performance_optimization", "low_level_programming"},
CollaborationDefaults: CollaborationConfig{
PreferredMessageTypes: []string{"task_help_request", "meta_discussion", "coordination_request"},
AutoSubscribeToRoles: []string{"specialist_3d", "senior_software_architect"},
AutoSubscribeToExpertise: []string{"3d_modeling", "architecture", "optimization"},
ResponseTimeoutSeconds: 300,
MaxCollaborationDepth: 4,
EscalationThreshold: 3,
},
},
}
}
// ApplyRoleDefinition applies a predefined role to the agent config
func (c *Config) ApplyRoleDefinition(roleName string) error {
roles := GetPredefinedRoles()
role, exists := roles[roleName]
if !exists {
return fmt.Errorf("unknown role: %s", roleName)
}
// Apply existing role configuration
c.Agent.Role = role.Name
c.Agent.SystemPrompt = role.SystemPrompt
c.Agent.ReportsTo = role.ReportsTo
c.Agent.Expertise = role.Expertise
c.Agent.Deliverables = role.Deliverables
c.Agent.Capabilities = role.Capabilities
c.Agent.CollaborationSettings = role.CollaborationDefaults
// Apply NEW authority and encryption settings
if role.Model != "" {
// Set primary model for this role
c.Agent.DefaultReasoningModel = role.Model
// Ensure it's in the models list
if !contains(c.Agent.Models, role.Model) {
c.Agent.Models = append([]string{role.Model}, c.Agent.Models...)
}
}
if role.MaxTasks > 0 {
c.Agent.MaxTasks = role.MaxTasks
}
// Apply special functions for admin roles
if role.AuthorityLevel == AuthorityMaster {
// Enable SLURP functionality for admin role
c.Slurp.Enabled = true
// Add special admin capabilities
adminCaps := []string{"context_curation", "decision_ingestion", "semantic_analysis", "key_reconstruction"}
for _, cap := range adminCaps {
if !contains(c.Agent.Capabilities, cap) {
c.Agent.Capabilities = append(c.Agent.Capabilities, cap)
}
}
}
return nil
}
// GetRoleByName returns a role definition by name (case-insensitive)
func GetRoleByName(roleName string) (*RoleDefinition, error) {
roles := GetPredefinedRoles()
// Try exact match first
if role, exists := roles[roleName]; exists {
return &role, nil
}
// Try case-insensitive match
lowerRoleName := strings.ToLower(roleName)
for key, role := range roles {
if strings.ToLower(key) == lowerRoleName {
return &role, nil
}
}
return nil, fmt.Errorf("role not found: %s", roleName)
}
// GetAvailableRoles returns a list of all available role names
func GetAvailableRoles() []string {
roles := GetPredefinedRoles()
names := make([]string, 0, len(roles))
for name := range roles {
names = append(names, name)
}
return names
}
// GetRoleAuthority returns the authority level for a given role
func (c *Config) GetRoleAuthority(roleName string) (AuthorityLevel, error) {
roles := GetPredefinedRoles()
role, exists := roles[roleName]
if !exists {
return AuthorityReadOnly, fmt.Errorf("role '%s' not found", roleName)
}
return role.AuthorityLevel, nil
}
// CanDecryptRole checks if current role can decrypt content from target role
func (c *Config) CanDecryptRole(targetRole string) (bool, error) {
if c.Agent.Role == "" {
return false, fmt.Errorf("no role configured")
}
roles := GetPredefinedRoles()
currentRole, exists := roles[c.Agent.Role]
if !exists {
return false, fmt.Errorf("current role '%s' not found", c.Agent.Role)
}
// Master authority can decrypt everything
if currentRole.AuthorityLevel == AuthorityMaster {
return true, nil
}
// Check if target role is in can_decrypt list
for _, role := range currentRole.CanDecrypt {
if role == targetRole || role == "*" {
return true, nil
}
}
return false, nil
}
// IsAdminRole checks if the current agent has admin (master) authority
func (c *Config) IsAdminRole() bool {
if c.Agent.Role == "" {
return false
}
authority, err := c.GetRoleAuthority(c.Agent.Role)
if err != nil {
return false
}
return authority == AuthorityMaster
}
// CanMakeDecisions checks if current role can make permanent decisions
func (c *Config) CanMakeDecisions() bool {
if c.Agent.Role == "" {
return false
}
authority, err := c.GetRoleAuthority(c.Agent.Role)
if err != nil {
return false
}
return authority == AuthorityMaster || authority == AuthorityDecision
}
// GetDecisionScope returns the decision domains this role can decide on
func (c *Config) GetDecisionScope() []string {
if c.Agent.Role == "" {
return []string{}
}
roles := GetPredefinedRoles()
role, exists := roles[c.Agent.Role]
if !exists {
return []string{}
}
return role.DecisionScope
}
// HasSpecialFunction checks if the current role has a specific special function
func (c *Config) HasSpecialFunction(function string) bool {
if c.Agent.Role == "" {
return false
}
roles := GetPredefinedRoles()
role, exists := roles[c.Agent.Role]
if !exists {
return false
}
for _, specialFunc := range role.SpecialFunctions {
if specialFunc == function {
return true
}
}
return false
}
// contains checks if a string slice contains a value
func contains(slice []string, value string) bool {
for _, item := range slice {
if item == value {
return true
}
}
return false
}

133
pkg/config/security.go Normal file
View File

@@ -0,0 +1,133 @@
package config
import "time"
// Authority levels for roles
const (
AuthorityReadOnly = "readonly"
AuthoritySuggestion = "suggestion"
AuthorityFull = "full"
AuthorityAdmin = "admin"
)
// SecurityConfig defines security-related configuration
type SecurityConfig struct {
KeyRotationDays int `yaml:"key_rotation_days"`
AuditLogging bool `yaml:"audit_logging"`
AuditPath string `yaml:"audit_path"`
ElectionConfig ElectionConfig `yaml:"election"`
}
// ElectionConfig defines election timing and behavior settings
type ElectionConfig struct {
DiscoveryTimeout time.Duration `yaml:"discovery_timeout"`
HeartbeatTimeout time.Duration `yaml:"heartbeat_timeout"`
ElectionTimeout time.Duration `yaml:"election_timeout"`
DiscoveryBackoff time.Duration `yaml:"discovery_backoff"`
LeadershipScoring *LeadershipScoring `yaml:"leadership_scoring,omitempty"`
}
// LeadershipScoring defines weights for election scoring
type LeadershipScoring struct {
UptimeWeight float64 `yaml:"uptime_weight"`
CapabilityWeight float64 `yaml:"capability_weight"`
ExperienceWeight float64 `yaml:"experience_weight"`
LoadWeight float64 `yaml:"load_weight"`
}
// AgeKeyPair represents an Age encryption key pair
type AgeKeyPair struct {
PublicKey string `yaml:"public_key"`
PrivateKey string `yaml:"private_key"`
}
// RoleDefinition represents a role configuration
type RoleDefinition struct {
Name string `yaml:"name"`
Description string `yaml:"description"`
Capabilities []string `yaml:"capabilities"`
AccessLevel string `yaml:"access_level"`
AuthorityLevel string `yaml:"authority_level"`
Keys *AgeKeyPair `yaml:"keys,omitempty"`
AgeKeys *AgeKeyPair `yaml:"age_keys,omitempty"` // Legacy field name
CanDecrypt []string `yaml:"can_decrypt,omitempty"` // Roles this role can decrypt
}
// GetPredefinedRoles returns the predefined roles for the system
func GetPredefinedRoles() map[string]*RoleDefinition {
return map[string]*RoleDefinition{
"project_manager": {
Name: "project_manager",
Description: "Project coordination and management",
Capabilities: []string{"coordination", "planning", "oversight"},
AccessLevel: "high",
AuthorityLevel: AuthorityAdmin,
CanDecrypt: []string{"project_manager", "backend_developer", "frontend_developer", "devops_engineer", "security_engineer"},
},
"backend_developer": {
Name: "backend_developer",
Description: "Backend development and API work",
Capabilities: []string{"backend", "api", "database"},
AccessLevel: "medium",
AuthorityLevel: AuthorityFull,
CanDecrypt: []string{"backend_developer"},
},
"frontend_developer": {
Name: "frontend_developer",
Description: "Frontend UI development",
Capabilities: []string{"frontend", "ui", "components"},
AccessLevel: "medium",
AuthorityLevel: AuthorityFull,
CanDecrypt: []string{"frontend_developer"},
},
"devops_engineer": {
Name: "devops_engineer",
Description: "Infrastructure and deployment",
Capabilities: []string{"infrastructure", "deployment", "monitoring"},
AccessLevel: "high",
AuthorityLevel: AuthorityFull,
CanDecrypt: []string{"devops_engineer", "backend_developer"},
},
"security_engineer": {
Name: "security_engineer",
Description: "Security oversight and hardening",
Capabilities: []string{"security", "audit", "compliance"},
AccessLevel: "high",
AuthorityLevel: AuthorityAdmin,
CanDecrypt: []string{"security_engineer", "project_manager", "backend_developer", "frontend_developer", "devops_engineer"},
},
}
}
// CanDecryptRole checks if the current agent can decrypt content for a target role
func (c *Config) CanDecryptRole(targetRole string) (bool, error) {
roles := GetPredefinedRoles()
currentRole, exists := roles[c.Agent.Role]
if !exists {
return false, nil
}
targetRoleDef, exists := roles[targetRole]
if !exists {
return false, nil
}
// Simple access level check
currentLevel := getAccessLevelValue(currentRole.AccessLevel)
targetLevel := getAccessLevelValue(targetRoleDef.AccessLevel)
return currentLevel >= targetLevel, nil
}
func getAccessLevelValue(level string) int {
switch level {
case "low":
return 1
case "medium":
return 2
case "high":
return 3
default:
return 0
}
}

289
pkg/config/slurp_config.go
View File

@@ -1,289 +0,0 @@
package config
import (
"fmt"
"time"
)
// SlurpConfig holds SLURP event system integration configuration
type SlurpConfig struct {
// Connection settings
Enabled bool `yaml:"enabled" json:"enabled"`
BaseURL string `yaml:"base_url" json:"base_url"`
APIKey string `yaml:"api_key" json:"api_key"`
Timeout time.Duration `yaml:"timeout" json:"timeout"`
RetryCount int `yaml:"retry_count" json:"retry_count"`
RetryDelay time.Duration `yaml:"retry_delay" json:"retry_delay"`
// Event generation settings
EventGeneration EventGenerationConfig `yaml:"event_generation" json:"event_generation"`
// Project-specific event mappings
ProjectMappings map[string]ProjectEventMapping `yaml:"project_mappings" json:"project_mappings"`
// Default event settings
DefaultEventSettings DefaultEventConfig `yaml:"default_event_settings" json:"default_event_settings"`
// Batch processing settings
BatchProcessing BatchConfig `yaml:"batch_processing" json:"batch_processing"`
// Reliability settings
Reliability ReliabilityConfig `yaml:"reliability" json:"reliability"`
}
// EventGenerationConfig controls when and how SLURP events are generated
type EventGenerationConfig struct {
// Consensus requirements
MinConsensusStrength float64 `yaml:"min_consensus_strength" json:"min_consensus_strength"`
MinParticipants int `yaml:"min_participants" json:"min_participants"`
RequireUnanimity bool `yaml:"require_unanimity" json:"require_unanimity"`
// Time-based triggers
MaxDiscussionDuration time.Duration `yaml:"max_discussion_duration" json:"max_discussion_duration"`
MinDiscussionDuration time.Duration `yaml:"min_discussion_duration" json:"min_discussion_duration"`
// Event type generation rules
EnabledEventTypes []string `yaml:"enabled_event_types" json:"enabled_event_types"`
DisabledEventTypes []string `yaml:"disabled_event_types" json:"disabled_event_types"`
// Severity calculation
SeverityRules SeverityConfig `yaml:"severity_rules" json:"severity_rules"`
}
// SeverityConfig defines how to calculate event severity from HMMM discussions
type SeverityConfig struct {
// Base severity for each event type (1-10 scale)
BaseSeverity map[string]int `yaml:"base_severity" json:"base_severity"`
// Modifiers based on discussion characteristics
ParticipantMultiplier float64 `yaml:"participant_multiplier" json:"participant_multiplier"`
DurationMultiplier float64 `yaml:"duration_multiplier" json:"duration_multiplier"`
UrgencyKeywords []string `yaml:"urgency_keywords" json:"urgency_keywords"`
UrgencyBoost int `yaml:"urgency_boost" json:"urgency_boost"`
// Severity caps
MinSeverity int `yaml:"min_severity" json:"min_severity"`
MaxSeverity int `yaml:"max_severity" json:"max_severity"`
}
// ProjectEventMapping defines project-specific event mapping rules
type ProjectEventMapping struct {
ProjectPath string `yaml:"project_path" json:"project_path"`
CustomEventTypes map[string]string `yaml:"custom_event_types" json:"custom_event_types"`
SeverityOverrides map[string]int `yaml:"severity_overrides" json:"severity_overrides"`
AdditionalMetadata map[string]interface{} `yaml:"additional_metadata" json:"additional_metadata"`
EventFilters []EventFilter `yaml:"event_filters" json:"event_filters"`
}
// EventFilter defines conditions for filtering or modifying events
type EventFilter struct {
Name string `yaml:"name" json:"name"`
Conditions map[string]string `yaml:"conditions" json:"conditions"`
Action string `yaml:"action" json:"action"` // "allow", "deny", "modify"
Modifications map[string]string `yaml:"modifications" json:"modifications"`
}
// DefaultEventConfig provides default settings for generated events
type DefaultEventConfig struct {
DefaultSeverity int `yaml:"default_severity" json:"default_severity"`
DefaultCreatedBy string `yaml:"default_created_by" json:"default_created_by"`
DefaultTags []string `yaml:"default_tags" json:"default_tags"`
MetadataTemplate map[string]string `yaml:"metadata_template" json:"metadata_template"`
}
// BatchConfig controls batch processing of SLURP events
type BatchConfig struct {
Enabled bool `yaml:"enabled" json:"enabled"`
MaxBatchSize int `yaml:"max_batch_size" json:"max_batch_size"`
MaxBatchWait time.Duration `yaml:"max_batch_wait" json:"max_batch_wait"`
FlushOnShutdown bool `yaml:"flush_on_shutdown" json:"flush_on_shutdown"`
}
// ReliabilityConfig controls reliability features (idempotency, circuit breaker, DLQ)
type ReliabilityConfig struct {
// Circuit breaker settings
MaxFailures int `yaml:"max_failures" json:"max_failures"`
CooldownPeriod time.Duration `yaml:"cooldown_period" json:"cooldown_period"`
HalfOpenTimeout time.Duration `yaml:"half_open_timeout" json:"half_open_timeout"`
// Idempotency settings
IdempotencyWindow time.Duration `yaml:"idempotency_window" json:"idempotency_window"`
// Dead letter queue settings
DLQDirectory string `yaml:"dlq_directory" json:"dlq_directory"`
MaxRetries int `yaml:"max_retries" json:"max_retries"`
RetryInterval time.Duration `yaml:"retry_interval" json:"retry_interval"`
// Backoff settings
InitialBackoff time.Duration `yaml:"initial_backoff" json:"initial_backoff"`
MaxBackoff time.Duration `yaml:"max_backoff" json:"max_backoff"`
BackoffMultiplier float64 `yaml:"backoff_multiplier" json:"backoff_multiplier"`
JitterFactor float64 `yaml:"jitter_factor" json:"jitter_factor"`
}
// HmmmToSlurpMapping defines the mapping between HMMM discussion outcomes and SLURP event types
type HmmmToSlurpMapping struct {
// Consensus types to SLURP event types
ConsensusApproval string `yaml:"consensus_approval" json:"consensus_approval"` // -> "approval"
RiskIdentified string `yaml:"risk_identified" json:"risk_identified"` // -> "warning"
CriticalBlocker string `yaml:"critical_blocker" json:"critical_blocker"` // -> "blocker"
PriorityChange string `yaml:"priority_change" json:"priority_change"` // -> "priority_change"
AccessRequest string `yaml:"access_request" json:"access_request"` // -> "access_update"
ArchitectureDecision string `yaml:"architecture_decision" json:"architecture_decision"` // -> "structural_change"
InformationShare string `yaml:"information_share" json:"information_share"` // -> "announcement"
// Keywords that trigger specific event types
ApprovalKeywords []string `yaml:"approval_keywords" json:"approval_keywords"`
WarningKeywords []string `yaml:"warning_keywords" json:"warning_keywords"`
BlockerKeywords []string `yaml:"blocker_keywords" json:"blocker_keywords"`
PriorityKeywords []string `yaml:"priority_keywords" json:"priority_keywords"`
AccessKeywords []string `yaml:"access_keywords" json:"access_keywords"`
StructuralKeywords []string `yaml:"structural_keywords" json:"structural_keywords"`
AnnouncementKeywords []string `yaml:"announcement_keywords" json:"announcement_keywords"`
}
// GetDefaultSlurpConfig returns default SLURP configuration
func GetDefaultSlurpConfig() SlurpConfig {
return SlurpConfig{
Enabled: false, // Disabled by default until configured
BaseURL: "http://localhost:8080",
Timeout: 30 * time.Second,
RetryCount: 3,
RetryDelay: 5 * time.Second,
EventGeneration: EventGenerationConfig{
MinConsensusStrength: 0.7,
MinParticipants: 2,
RequireUnanimity: false,
MaxDiscussionDuration: 30 * time.Minute,
MinDiscussionDuration: 1 * time.Minute,
EnabledEventTypes: []string{
"announcement", "warning", "blocker", "approval",
"priority_change", "access_update", "structural_change",
},
DisabledEventTypes: []string{},
SeverityRules: SeverityConfig{
BaseSeverity: map[string]int{
"announcement": 3,
"warning": 5,
"blocker": 8,
"approval": 4,
"priority_change": 6,
"access_update": 5,
"structural_change": 7,
},
ParticipantMultiplier: 0.2,
DurationMultiplier: 0.1,
UrgencyKeywords: []string{"urgent", "critical", "blocker", "emergency", "immediate"},
UrgencyBoost: 2,
MinSeverity: 1,
MaxSeverity: 10,
},
},
ProjectMappings: make(map[string]ProjectEventMapping),
DefaultEventSettings: DefaultEventConfig{
DefaultSeverity: 5,
DefaultCreatedBy: "hmmm-consensus",
DefaultTags: []string{"hmmm-generated", "automated"},
MetadataTemplate: map[string]string{
"source": "hmmm-discussion",
"generation_type": "consensus-based",
},
},
BatchProcessing: BatchConfig{
Enabled: true,
MaxBatchSize: 10,
MaxBatchWait: 5 * time.Second,
FlushOnShutdown: true,
},
Reliability: ReliabilityConfig{
// Circuit breaker: allow 5 consecutive failures before opening for 1 minute
MaxFailures: 5,
CooldownPeriod: 1 * time.Minute,
HalfOpenTimeout: 30 * time.Second,
// Idempotency: 1-hour window to catch duplicate events
IdempotencyWindow: 1 * time.Hour,
// DLQ: retry up to 3 times with exponential backoff
DLQDirectory: "./data/slurp_dlq",
MaxRetries: 3,
RetryInterval: 30 * time.Second,
// Backoff: start with 1s, max 5min, 2x multiplier, ±25% jitter
InitialBackoff: 1 * time.Second,
MaxBackoff: 5 * time.Minute,
BackoffMultiplier: 2.0,
JitterFactor: 0.25,
},
}
}
// GetHmmmToSlurpMapping returns the default mapping configuration
func GetHmmmToSlurpMapping() HmmmToSlurpMapping {
return HmmmToSlurpMapping{
ConsensusApproval: "approval",
RiskIdentified: "warning",
CriticalBlocker: "blocker",
PriorityChange: "priority_change",
AccessRequest: "access_update",
ArchitectureDecision: "structural_change",
InformationShare: "announcement",
ApprovalKeywords: []string{"approve", "approved", "looks good", "lgtm", "accepted", "agree"},
WarningKeywords: []string{"warning", "caution", "risk", "potential issue", "concern", "careful"},
BlockerKeywords: []string{"blocker", "blocked", "critical", "urgent", "cannot proceed", "show stopper"},
PriorityKeywords: []string{"priority", "urgent", "high priority", "low priority", "reprioritize"},
AccessKeywords: []string{"access", "permission", "auth", "authorization", "credentials", "token"},
StructuralKeywords: []string{"architecture", "structure", "design", "refactor", "framework", "pattern"},
AnnouncementKeywords: []string{"announce", "fyi", "information", "update", "news", "notice"},
}
}
// ValidateSlurpConfig validates SLURP configuration
func ValidateSlurpConfig(config SlurpConfig) error {
if config.Enabled {
if config.BaseURL == "" {
return fmt.Errorf("slurp.base_url is required when SLURP is enabled")
}
if config.EventGeneration.MinConsensusStrength < 0 || config.EventGeneration.MinConsensusStrength > 1 {
return fmt.Errorf("slurp.event_generation.min_consensus_strength must be between 0 and 1")
}
if config.EventGeneration.MinParticipants < 1 {
return fmt.Errorf("slurp.event_generation.min_participants must be at least 1")
}
if config.DefaultEventSettings.DefaultSeverity < 1 || config.DefaultEventSettings.DefaultSeverity > 10 {
return fmt.Errorf("slurp.default_event_settings.default_severity must be between 1 and 10")
}
// Validate reliability settings
if config.Reliability.MaxFailures < 1 {
return fmt.Errorf("slurp.reliability.max_failures must be at least 1")
}
if config.Reliability.CooldownPeriod <= 0 {
return fmt.Errorf("slurp.reliability.cooldown_period must be positive")
}
if config.Reliability.IdempotencyWindow <= 0 {
return fmt.Errorf("slurp.reliability.idempotency_window must be positive")
}
if config.Reliability.MaxRetries < 0 {
return fmt.Errorf("slurp.reliability.max_retries cannot be negative")
}
if config.Reliability.BackoffMultiplier <= 1.0 {
return fmt.Errorf("slurp.reliability.backoff_multiplier must be greater than 1.0")
}
}
return nil
}

2
pkg/coordination/dependency_detector.go
View File

@@ -6,7 +6,7 @@ import (
"strings" "strings"
"time" "time"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
) )

6
pkg/coordination/meta_coordinator.go
View File

@@ -8,9 +8,9 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/integration" "chorus/pkg/integration"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
"chorus.services/bzzz/reasoning" "chorus/reasoning"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
) )

52
pkg/crypto/README.md
View File

@@ -1,8 +1,8 @@
# BZZZ Role-Based Encryption System # CHORUS Role-Based Encryption System
## Overview ## Overview
The BZZZ Role-Based Encryption System provides enterprise-grade security for the SLURP (Storage, Logic, Understanding, Retrieval, Processing) contextual intelligence system. This comprehensive encryption scheme implements multi-layer encryption, sophisticated access controls, and compliance monitoring to ensure that each AI agent role receives exactly the contextual understanding they need while maintaining strict security boundaries. The CHORUS Role-Based Encryption System provides enterprise-grade security for the SLURP (Storage, Logic, Understanding, Retrieval, Processing) contextual intelligence system. This comprehensive encryption scheme implements multi-layer encryption, sophisticated access controls, and compliance monitoring to ensure that each AI agent role receives exactly the contextual understanding they need while maintaining strict security boundaries.
## Table of Contents ## Table of Contents
@@ -212,10 +212,10 @@ import (
"fmt" "fmt"
"time" "time"
"github.com/anthonyrawlins/bzzz/pkg/config" "github.com/anthonyrawlins/CHORUS/pkg/config"
"github.com/anthonyrawlins/bzzz/pkg/crypto" "github.com/anthonyrawlins/CHORUS/pkg/crypto"
"github.com/anthonyrawlins/bzzz/pkg/ucxl" "github.com/anthonyrawlins/CHORUS/pkg/ucxl"
slurpContext "github.com/anthonyrawlins/bzzz/pkg/slurp/context" slurpContext "github.com/anthonyrawlins/CHORUS/pkg/slurp/context"
) )
func main() { func main() {
@@ -603,15 +603,15 @@ Current test coverage: **95%+**
# docker-compose.yml # docker-compose.yml
version: '3.8' version: '3.8'
services: services:
bzzz-crypto: CHORUS-crypto:
image: bzzz/crypto-service:latest image: CHORUS/crypto-service:latest
environment: environment:
- BZZZ_CONFIG_PATH=/etc/bzzz/config.yaml - BZZZ_CONFIG_PATH=/etc/CHORUS/config.yaml
- BZZZ_LOG_LEVEL=info - BZZZ_LOG_LEVEL=info
- BZZZ_AUDIT_STORAGE=postgresql - BZZZ_AUDIT_STORAGE=postgresql
volumes: volumes:
- ./config:/etc/bzzz - ./config:/etc/CHORUS
- ./logs:/var/log/bzzz - ./logs:/var/log/CHORUS
ports: ports:
- "8443:8443" - "8443:8443"
depends_on: depends_on:
@@ -622,7 +622,7 @@ services:
image: postgres:13 image: postgres:13
environment: environment:
- POSTGRES_DB=bzzz_audit - POSTGRES_DB=bzzz_audit
- POSTGRES_USER=bzzz - POSTGRES_USER=CHORUS
- POSTGRES_PASSWORD_FILE=/run/secrets/db_password - POSTGRES_PASSWORD_FILE=/run/secrets/db_password
volumes: volumes:
- postgres_data:/var/lib/postgresql/data - postgres_data:/var/lib/postgresql/data
@@ -650,39 +650,39 @@ secrets:
apiVersion: apps/v1 apiVersion: apps/v1
kind: Deployment kind: Deployment
metadata: metadata:
name: bzzz-crypto-service name: CHORUS-crypto-service
labels: labels:
app: bzzz-crypto app: CHORUS-crypto
spec: spec:
replicas: 3 replicas: 3
selector: selector:
matchLabels: matchLabels:
app: bzzz-crypto app: CHORUS-crypto
template: template:
metadata: metadata:
labels: labels:
app: bzzz-crypto app: CHORUS-crypto
spec: spec:
serviceAccountName: bzzz-crypto serviceAccountName: CHORUS-crypto
securityContext: securityContext:
runAsNonRoot: true runAsNonRoot: true
runAsUser: 1000 runAsUser: 1000
fsGroup: 1000 fsGroup: 1000
containers: containers:
- name: crypto-service - name: crypto-service
image: bzzz/crypto-service:v1.0.0 image: CHORUS/crypto-service:v1.0.0
imagePullPolicy: Always imagePullPolicy: Always
ports: ports:
- containerPort: 8443 - containerPort: 8443
name: https name: https
env: env:
- name: BZZZ_CONFIG_PATH - name: BZZZ_CONFIG_PATH
value: "/etc/bzzz/config.yaml" value: "/etc/CHORUS/config.yaml"
- name: BZZZ_LOG_LEVEL - name: BZZZ_LOG_LEVEL
value: "info" value: "info"
volumeMounts: volumeMounts:
- name: config - name: config
mountPath: /etc/bzzz mountPath: /etc/CHORUS
readOnly: true readOnly: true
- name: secrets - name: secrets
mountPath: /etc/secrets mountPath: /etc/secrets
@@ -711,18 +711,18 @@ spec:
volumes: volumes:
- name: config - name: config
configMap: configMap:
name: bzzz-crypto-config name: CHORUS-crypto-config
- name: secrets - name: secrets
secret: secret:
secretName: bzzz-crypto-secrets secretName: CHORUS-crypto-secrets
--- ---
apiVersion: v1 apiVersion: v1
kind: Service kind: Service
metadata: metadata:
name: bzzz-crypto-service name: CHORUS-crypto-service
spec: spec:
selector: selector:
app: bzzz-crypto app: CHORUS-crypto
ports: ports:
- port: 443 - port: 443
targetPort: 8443 targetPort: 8443
@@ -805,7 +805,7 @@ groups:
```json ```json
{ {
"dashboard": { "dashboard": {
"title": "BZZZ Crypto Security Dashboard", "title": "CHORUS Crypto Security Dashboard",
"panels": [ "panels": [
{ {
"title": "Security Events", "title": "Security Events",
@@ -844,7 +844,7 @@ groups:
## Conclusion ## Conclusion
The BZZZ Role-Based Encryption System provides enterprise-grade security for contextual intelligence with comprehensive features including multi-layer encryption, sophisticated access controls, automated key management, and extensive compliance monitoring. The system is designed to scale to enterprise requirements while maintaining the highest security standards and providing complete audit transparency. The CHORUS Role-Based Encryption System provides enterprise-grade security for contextual intelligence with comprehensive features including multi-layer encryption, sophisticated access controls, automated key management, and extensive compliance monitoring. The system is designed to scale to enterprise requirements while maintaining the highest security standards and providing complete audit transparency.
For additional information, support, or contributions, please refer to the project documentation or contact the security team. For additional information, support, or contributions, please refer to the project documentation or contact the security team.

14
pkg/crypto/age_crypto.go
View File

@@ -1,6 +1,6 @@
// Package crypto provides Age encryption implementation for role-based content security in BZZZ. // Package crypto provides Age encryption implementation for role-based content security in CHORUS.
// //
// This package implements the cryptographic foundation for BZZZ Phase 2B, enabling: // This package implements the cryptographic foundation for CHORUS Phase 2B, enabling:
// - Role-based content encryption using Age (https://age-encryption.org) // - Role-based content encryption using Age (https://age-encryption.org)
// - Hierarchical access control based on agent authority levels // - Hierarchical access control based on agent authority levels
// - Multi-recipient encryption for shared content // - Multi-recipient encryption for shared content
@@ -36,13 +36,13 @@ import (
"strings" "strings"
"filippo.io/age" // Modern, secure encryption library "filippo.io/age" // Modern, secure encryption library
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// AgeCrypto handles Age encryption for role-based content security. // AgeCrypto handles Age encryption for role-based content security.
// //
// This is the primary interface for encrypting and decrypting UCXL content // This is the primary interface for encrypting and decrypting UCXL content
// based on BZZZ role hierarchies. It provides methods to: // based on CHORUS role hierarchies. It provides methods to:
// - Encrypt content for specific roles or multiple roles // - Encrypt content for specific roles or multiple roles
// - Decrypt content using the current agent's role key // - Decrypt content using the current agent's role key
// - Validate Age key formats and generate new key pairs // - Validate Age key formats and generate new key pairs
@@ -55,13 +55,13 @@ import (
// //
// Thread Safety: AgeCrypto is safe for concurrent use across goroutines. // Thread Safety: AgeCrypto is safe for concurrent use across goroutines.
type AgeCrypto struct { type AgeCrypto struct {
config *config.Config // BZZZ configuration containing role definitions config *config.Config // CHORUS configuration containing role definitions
} }
// NewAgeCrypto creates a new Age crypto handler for role-based encryption. // NewAgeCrypto creates a new Age crypto handler for role-based encryption.
// //
// Parameters: // Parameters:
// cfg: BZZZ configuration containing role definitions and agent settings // cfg: CHORUS configuration containing role definitions and agent settings
// //
// Returns: // Returns:
// *AgeCrypto: Configured crypto handler ready for encryption/decryption // *AgeCrypto: Configured crypto handler ready for encryption/decryption
@@ -81,7 +81,7 @@ func NewAgeCrypto(cfg *config.Config) *AgeCrypto {
// GenerateAgeKeyPair generates a new Age X25519 key pair for role-based encryption. // GenerateAgeKeyPair generates a new Age X25519 key pair for role-based encryption.
// //
// This function creates cryptographically secure Age key pairs suitable for // This function creates cryptographically secure Age key pairs suitable for
// role-based content encryption. Each role in BZZZ should have its own key pair // role-based content encryption. Each role in CHORUS should have its own key pair
// to enable proper access control and content segmentation. // to enable proper access control and content segmentation.
// //
// Returns: // Returns:

2
pkg/crypto/audit_logger.go
View File

@@ -36,7 +36,7 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// AuditLoggerImpl implements comprehensive audit logging // AuditLoggerImpl implements comprehensive audit logging

4
pkg/crypto/key_manager.go
View File

@@ -31,8 +31,8 @@ import (
"time" "time"
"golang.org/x/crypto/pbkdf2" "golang.org/x/crypto/pbkdf2"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/security" "chorus/pkg/security"
) )
// Type aliases for backward compatibility // Type aliases for backward compatibility

6
pkg/crypto/role_crypto_test.go
View File

@@ -29,9 +29,9 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite" "github.com/stretchr/testify/suite"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// RoleCryptoTestSuite provides comprehensive testing for role-based encryption // RoleCryptoTestSuite provides comprehensive testing for role-based encryption

2
pkg/crypto/security_test.go
View File

@@ -9,7 +9,7 @@ import (
"testing" "testing"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// TestSecurityConfig tests SecurityConfig enforcement // TestSecurityConfig tests SecurityConfig enforcement

16
pkg/dht/dht.go
View File

@@ -17,7 +17,7 @@ import (
"crypto/sha256" "crypto/sha256"
) )
// LibP2PDHT provides distributed hash table functionality for BZZZ peer discovery // LibP2PDHT provides distributed hash table functionality for CHORUS peer discovery
type LibP2PDHT struct { type LibP2PDHT struct {
host host.Host host host.Host
kdht *dht.IpfsDHT kdht *dht.IpfsDHT
@@ -42,7 +42,7 @@ type Config struct {
// Bootstrap nodes for initial DHT discovery // Bootstrap nodes for initial DHT discovery
BootstrapPeers []multiaddr.Multiaddr BootstrapPeers []multiaddr.Multiaddr
// Protocol prefix for BZZZ DHT // Protocol prefix for CHORUS DHT
ProtocolPrefix string ProtocolPrefix string
// Bootstrap timeout // Bootstrap timeout
@@ -71,7 +71,7 @@ type PeerInfo struct {
// DefaultConfig returns a default DHT configuration // DefaultConfig returns a default DHT configuration
func DefaultConfig() *Config { func DefaultConfig() *Config {
return &Config{ return &Config{
ProtocolPrefix: "/bzzz", ProtocolPrefix: "/CHORUS",
BootstrapTimeout: 30 * time.Second, BootstrapTimeout: 30 * time.Second,
DiscoveryInterval: 60 * time.Second, DiscoveryInterval: 60 * time.Second,
Mode: dht.ModeAuto, Mode: dht.ModeAuto,
@@ -373,7 +373,7 @@ func (d *LibP2PDHT) FindPeersByRole(ctx context.Context, role string) ([]*PeerIn
d.peersMutex.RUnlock() d.peersMutex.RUnlock()
// Also search DHT for role-based keys // Also search DHT for role-based keys
roleKey := fmt.Sprintf("bzzz:role:%s", role) roleKey := fmt.Sprintf("CHORUS:role:%s", role)
providers, err := d.FindProviders(ctx, roleKey, 10) providers, err := d.FindProviders(ctx, roleKey, 10)
if err != nil { if err != nil {
// Return local peers even if DHT search fails // Return local peers even if DHT search fails
@@ -408,13 +408,13 @@ func (d *LibP2PDHT) FindPeersByRole(ctx context.Context, role string) ([]*PeerIn
// AnnounceRole announces this peer's role to the DHT // AnnounceRole announces this peer's role to the DHT
func (d *LibP2PDHT) AnnounceRole(ctx context.Context, role string) error { func (d *LibP2PDHT) AnnounceRole(ctx context.Context, role string) error {
roleKey := fmt.Sprintf("bzzz:role:%s", role) roleKey := fmt.Sprintf("CHORUS:role:%s", role)
return d.Provide(ctx, roleKey) return d.Provide(ctx, roleKey)
} }
// AnnounceCapability announces a capability to the DHT // AnnounceCapability announces a capability to the DHT
func (d *LibP2PDHT) AnnounceCapability(ctx context.Context, capability string) error { func (d *LibP2PDHT) AnnounceCapability(ctx context.Context, capability string) error {
capKey := fmt.Sprintf("bzzz:capability:%s", capability) capKey := fmt.Sprintf("CHORUS:capability:%s", capability)
return d.Provide(ctx, capKey) return d.Provide(ctx, capKey)
} }
@@ -474,8 +474,8 @@ func (d *LibP2PDHT) performDiscovery() {
ctx, cancel := context.WithTimeout(d.ctx, 30*time.Second) ctx, cancel := context.WithTimeout(d.ctx, 30*time.Second)
defer cancel() defer cancel()
// Look for general BZZZ peers // Look for general CHORUS peers
providers, err := d.FindProviders(ctx, "bzzz:peer", 10) providers, err := d.FindProviders(ctx, "CHORUS:peer", 10)
if err != nil { if err != nil {
return return
} }

8
pkg/dht/dht_test.go
View File

@@ -15,8 +15,8 @@ import (
func TestDefaultConfig(t *testing.T) { func TestDefaultConfig(t *testing.T) {
config := DefaultConfig() config := DefaultConfig()
if config.ProtocolPrefix != "/bzzz" { if config.ProtocolPrefix != "/CHORUS" {
t.Errorf("expected protocol prefix '/bzzz', got %s", config.ProtocolPrefix) t.Errorf("expected protocol prefix '/CHORUS', got %s", config.ProtocolPrefix)
} }
if config.BootstrapTimeout != 30*time.Second { if config.BootstrapTimeout != 30*time.Second {
@@ -53,8 +53,8 @@ func TestNewDHT(t *testing.T) {
t.Error("host not set correctly") t.Error("host not set correctly")
} }
if d.config.ProtocolPrefix != "/bzzz" { if d.config.ProtocolPrefix != "/CHORUS" {
t.Errorf("expected protocol prefix '/bzzz', got %s", d.config.ProtocolPrefix) t.Errorf("expected protocol prefix '/CHORUS', got %s", d.config.ProtocolPrefix)
} }
} }

14
pkg/dht/encrypted_storage.go
View File

@@ -10,10 +10,10 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/crypto" "chorus/pkg/crypto"
"chorus.services/bzzz/pkg/storage" "chorus/pkg/storage"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
"github.com/libp2p/go-libp2p/core/host" "github.com/libp2p/go-libp2p/core/host"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
) )
@@ -404,7 +404,7 @@ type StorageEntry struct {
func (eds *EncryptedDHTStorage) generateDHTKey(ucxlAddress string) string { func (eds *EncryptedDHTStorage) generateDHTKey(ucxlAddress string) string {
// Use SHA256 hash of the UCXL address as DHT key // Use SHA256 hash of the UCXL address as DHT key
hash := sha256.Sum256([]byte(ucxlAddress)) hash := sha256.Sum256([]byte(ucxlAddress))
return "/bzzz/ucxl/" + base64.URLEncoding.EncodeToString(hash[:]) return "/CHORUS/ucxl/" + base64.URLEncoding.EncodeToString(hash[:])
} }
// getDecryptableRoles determines which roles can decrypt content from a creator // getDecryptableRoles determines which roles can decrypt content from a creator
@@ -610,7 +610,7 @@ func (eds *EncryptedDHTStorage) AnnounceContent(ucxlAddress string) error {
} }
// Announce via DHT // Announce via DHT
dhtKey := "/bzzz/announcements/" + eds.generateDHTKey(ucxlAddress) dhtKey := "/CHORUS/announcements/" + eds.generateDHTKey(ucxlAddress)
err = eds.dht.PutValue(eds.ctx, dhtKey, announcementData) err = eds.dht.PutValue(eds.ctx, dhtKey, announcementData)
// Audit the announce operation // Audit the announce operation
@@ -627,7 +627,7 @@ func (eds *EncryptedDHTStorage) AnnounceContent(ucxlAddress string) error {
// DiscoverContentPeers discovers peers that have specific UCXL content // DiscoverContentPeers discovers peers that have specific UCXL content
func (eds *EncryptedDHTStorage) DiscoverContentPeers(ucxlAddress string) ([]peer.ID, error) { func (eds *EncryptedDHTStorage) DiscoverContentPeers(ucxlAddress string) ([]peer.ID, error) {
dhtKey := "/bzzz/announcements/" + eds.generateDHTKey(ucxlAddress) dhtKey := "/CHORUS/announcements/" + eds.generateDHTKey(ucxlAddress)
// This is a simplified implementation // This is a simplified implementation
// In a real system, you'd query multiple announcement keys // In a real system, you'd query multiple announcement keys

2
pkg/dht/encrypted_storage_security_test.go
View File

@@ -5,7 +5,7 @@ import (
"testing" "testing"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// TestDHTSecurityPolicyEnforcement tests security policy enforcement in DHT operations // TestDHTSecurityPolicyEnforcement tests security policy enforcement in DHT operations

2
pkg/dht/hybrid_dht.go
View File

@@ -6,7 +6,7 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
) )

2
pkg/dht/real_dht.go
View File

@@ -3,7 +3,7 @@ package dht
import ( import (
"fmt" "fmt"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// NewRealDHT creates a new real DHT implementation // NewRealDHT creates a new real DHT implementation

12
pkg/election/election.go
View File

@@ -9,8 +9,8 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
libp2p "github.com/libp2p/go-libp2p/core/host" libp2p "github.com/libp2p/go-libp2p/core/host"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
) )
@@ -150,11 +150,11 @@ func (em *ElectionManager) Start() error {
log.Printf("🗳️ Starting election manager for node %s", em.nodeID) log.Printf("🗳️ Starting election manager for node %s", em.nodeID)
// TODO: Subscribe to election-related messages - pubsub interface needs update // TODO: Subscribe to election-related messages - pubsub interface needs update
// if err := em.pubsub.Subscribe("bzzz/election/v1", em.handleElectionMessage); err != nil { // if err := em.pubsub.Subscribe("CHORUS/election/v1", em.handleElectionMessage); err != nil {
// return fmt.Errorf("failed to subscribe to election messages: %w", err) // return fmt.Errorf("failed to subscribe to election messages: %w", err)
// } // }
// //
// if err := em.pubsub.Subscribe("bzzz/admin/heartbeat/v1", em.handleAdminHeartbeat); err != nil { // if err := em.pubsub.Subscribe("CHORUS/admin/heartbeat/v1", em.handleAdminHeartbeat); err != nil {
// return fmt.Errorf("failed to subscribe to admin heartbeat: %w", err) // return fmt.Errorf("failed to subscribe to admin heartbeat: %w", err)
// } // }
@@ -840,7 +840,7 @@ func (em *ElectionManager) publishElectionMessage(msg ElectionMessage) error {
} }
// TODO: Fix pubsub interface // TODO: Fix pubsub interface
// return em.pubsub.Publish("bzzz/election/v1", data) // return em.pubsub.Publish("CHORUS/election/v1", data)
_ = data // Avoid unused variable _ = data // Avoid unused variable
return nil return nil
} }
@@ -865,7 +865,7 @@ func (em *ElectionManager) SendAdminHeartbeat() error {
} }
// TODO: Fix pubsub interface // TODO: Fix pubsub interface
// return em.pubsub.Publish("bzzz/admin/heartbeat/v1", data) // return em.pubsub.Publish("CHORUS/admin/heartbeat/v1", data)
_ = data // Avoid unused variable _ = data // Avoid unused variable
return nil return nil
} }

2
pkg/election/election_test.go
View File

@@ -5,7 +5,7 @@ import (
"testing" "testing"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
func TestElectionManager_NewElectionManager(t *testing.T) { func TestElectionManager_NewElectionManager(t *testing.T) {

2
pkg/election/slurp_election.go
View File

@@ -4,7 +4,7 @@ import (
"context" "context"
"time" "time"
// slurpContext "chorus.services/bzzz/pkg/slurp/context" // slurpContext "chorus/pkg/slurp/context"
) )
// SLURPElection extends the base Election interface to include Project Manager contextual intelligence duties // SLURPElection extends the base Election interface to include Project Manager contextual intelligence duties

4
pkg/election/slurp_manager.go
View File

@@ -9,8 +9,8 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
libp2p "github.com/libp2p/go-libp2p/core/host" libp2p "github.com/libp2p/go-libp2p/core/host"
) )

2
pkg/election/slurp_scoring.go
View File

@@ -5,7 +5,7 @@ import (
"log" "log"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// SLURPCandidateCapabilities represents SLURP-specific capabilities for election candidates // SLURPCandidateCapabilities represents SLURP-specific capabilities for election candidates

4
pkg/health/adapters.go
View File

@@ -5,8 +5,8 @@ import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
) )
// PubSubAdapter adapts the existing PubSub system to the health check interface // PubSubAdapter adapts the existing PubSub system to the health check interface

10
pkg/health/enhanced_health_checks.go
View File

@@ -7,12 +7,12 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/election" "chorus/pkg/election"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
) )
// EnhancedHealthChecks provides comprehensive health monitoring for BZZZ infrastructure // EnhancedHealthChecks provides comprehensive health monitoring for CHORUS infrastructure
type EnhancedHealthChecks struct { type EnhancedHealthChecks struct {
mu sync.RWMutex mu sync.RWMutex
manager *Manager manager *Manager
@@ -211,7 +211,7 @@ func (ehc *EnhancedHealthChecks) createEnhancedPubSubCheck() *HealthCheck {
// Generate unique test data // Generate unique test data
testID := fmt.Sprintf("health-test-%d", time.Now().UnixNano()) testID := fmt.Sprintf("health-test-%d", time.Now().UnixNano())
testTopic := "bzzz/health/enhanced/v1" testTopic := "CHORUS/health/enhanced/v1"
testData := map[string]interface{}{ testData := map[string]interface{}{
"test_id": testID, "test_id": testID,

4
pkg/health/integration_example.go
View File

@@ -6,7 +6,7 @@ import (
"net/http" "net/http"
"time" "time"
"chorus.services/bzzz/pkg/shutdown" "chorus/pkg/shutdown"
) )
// IntegrationExample demonstrates how to integrate health monitoring and graceful shutdown // IntegrationExample demonstrates how to integrate health monitoring and graceful shutdown
@@ -75,7 +75,7 @@ func setupHealthChecks(healthManager *Manager) {
healthManager.RegisterCheck(memoryCheck) healthManager.RegisterCheck(memoryCheck)
// Disk space check (warning only) // Disk space check (warning only)
diskCheck := CreateDiskSpaceCheck("/var/lib/bzzz", 0.90) // Alert if > 90% diskCheck := CreateDiskSpaceCheck("/var/lib/CHORUS", 0.90) // Alert if > 90%
healthManager.RegisterCheck(diskCheck) healthManager.RegisterCheck(diskCheck)
// Custom application-specific health check // Custom application-specific health check

4
pkg/health/manager.go
View File

@@ -8,7 +8,7 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/shutdown" "chorus/pkg/shutdown"
) )
// Manager provides comprehensive health monitoring and integrates with graceful shutdown // Manager provides comprehensive health monitoring and integrates with graceful shutdown
@@ -565,7 +565,7 @@ func CreateActivePubSubCheck(pubsub PubSubInterface) *HealthCheck {
} }
// Subscribe to test topic // Subscribe to test topic
testTopic := "bzzz/health-test/v1" testTopic := "CHORUS/health-test/v1"
if err := pubsub.SubscribeToTopic(testTopic, handler); err != nil { if err := pubsub.SubscribeToTopic(testTopic, handler); err != nil {
return CheckResult{ return CheckResult{
Healthy: false, Healthy: false,

38
pkg/hmmm/types.go Normal file
View File

@@ -0,0 +1,38 @@
package hmmm
import (
"context"
"chorus/pubsub"
)
// Message represents an HMMM message
type Message struct {
Topic string `json:"topic"`
Type string `json:"type"`
Payload map[string]interface{} `json:"payload"`
Version interface{} `json:"version"` // Can be string or int
IssueID int64 `json:"issue_id"`
ThreadID string `json:"thread_id"`
MsgID string `json:"msg_id"`
NodeID string `json:"node_id"`
HopCount int `json:"hop_count"`
Timestamp interface{} `json:"timestamp"`
Message string `json:"message"`
}
// Router provides HMMM routing functionality using the underlying pubsub system
type Router struct {
pubsub *pubsub.PubSub
}
// NewRouter creates a new HMMM router
func NewRouter(ps *pubsub.PubSub) *Router {
return &Router{
pubsub: ps,
}
}
// Publish publishes an HMMM message to the network
func (r *Router) Publish(ctx context.Context, msg Message) error {
return r.pubsub.PublishToDynamicTopic(msg.Topic, pubsub.MessageType(msg.Type), msg.Payload)
}

4
pkg/hmmm_adapter/adapter_stub.go
View File

@@ -13,7 +13,7 @@ type Joiner func(topic string) error
// Publisher publishes a raw JSON payload to a topic. // Publisher publishes a raw JSON payload to a topic.
type Publisher func(topic string, payload []byte) error type Publisher func(topic string, payload []byte) error
// Adapter bridges BZZZ pub/sub to a RawPublisher-compatible interface. // Adapter bridges CHORUS pub/sub to a RawPublisher-compatible interface.
// It does not impose any message envelope so HMMM can publish raw JSON frames. // It does not impose any message envelope so HMMM can publish raw JSON frames.
// The adapter provides additional features like topic caching, metrics, and validation. // The adapter provides additional features like topic caching, metrics, and validation.
type Adapter struct { type Adapter struct {
@@ -53,7 +53,7 @@ func DefaultAdapterConfig() AdapterConfig {
} }
// NewAdapter constructs a new adapter with explicit join/publish hooks. // NewAdapter constructs a new adapter with explicit join/publish hooks.
// Wire these to BZZZ pubsub methods, e.g., JoinDynamicTopic and a thin PublishRaw helper. // Wire these to CHORUS pubsub methods, e.g., JoinDynamicTopic and a thin PublishRaw helper.
func NewAdapter(join Joiner, publish Publisher) *Adapter { func NewAdapter(join Joiner, publish Publisher) *Adapter {
return NewAdapterWithConfig(join, publish, DefaultAdapterConfig()) return NewAdapterWithConfig(join, publish, DefaultAdapterConfig())
} }

10
pkg/hmmm_adapter/adapter_stub_test.go
View File

@@ -13,10 +13,10 @@ import (
func TestAdapter_Publish_OK(t *testing.T) { func TestAdapter_Publish_OK(t *testing.T) {
var joined, published bool var joined, published bool
a := NewAdapter( a := NewAdapter(
func(topic string) error { joined = (topic == "bzzz/meta/issue/42"); return nil }, func(topic string) error { joined = (topic == "CHORUS/meta/issue/42"); return nil },
func(topic string, payload []byte) error { published = (topic == "bzzz/meta/issue/42" && len(payload) > 0); return nil }, func(topic string, payload []byte) error { published = (topic == "CHORUS/meta/issue/42" && len(payload) > 0); return nil },
) )
if err := a.Publish(context.Background(), "bzzz/meta/issue/42", []byte(`{"ok":true}`)); err != nil { if err := a.Publish(context.Background(), "CHORUS/meta/issue/42", []byte(`{"ok":true}`)); err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
if !joined || !published { if !joined || !published {
@@ -130,7 +130,7 @@ func TestAdapter_Publish_TopicCaching(t *testing.T) {
func(topic string, payload []byte) error { return nil }, func(topic string, payload []byte) error { return nil },
) )
topic := "bzzz/meta/issue/123" topic := "CHORUS/meta/issue/123"
// First publish should join // First publish should join
err := a.Publish(context.Background(), topic, []byte(`{"msg1":true}`)) err := a.Publish(context.Background(), topic, []byte(`{"msg1":true}`))
@@ -233,7 +233,7 @@ func TestAdapter_ConcurrentPublish(t *testing.T) {
for i := 0; i < numGoroutines; i++ { for i := 0; i < numGoroutines; i++ {
go func(id int) { go func(id int) {
defer wg.Done() defer wg.Done()
topic := fmt.Sprintf("bzzz/meta/issue/%d", id%numTopics) topic := fmt.Sprintf("CHORUS/meta/issue/%d", id%numTopics)
payload := fmt.Sprintf(`{"id":%d}`, id) payload := fmt.Sprintf(`{"id":%d}`, id)
err := a.Publish(context.Background(), topic, []byte(payload)) err := a.Publish(context.Background(), topic, []byte(payload))

22
pkg/hmmm_adapter/integration_test.go
View File

@@ -7,12 +7,12 @@ import (
"testing" "testing"
"time" "time"
"chorus.services/bzzz/p2p" "chorus/p2p"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
"chorus.services/hmmm/pkg/hmmm" "chorus/pkg/hmmm"
) )
// TestAdapterPubSubIntegration tests the complete integration between the adapter and BZZZ pubsub // TestAdapterPubSubIntegration tests the complete integration between the adapter and CHORUS pubsub
func TestAdapterPubSubIntegration(t *testing.T) { func TestAdapterPubSubIntegration(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
@@ -25,20 +25,20 @@ func TestAdapterPubSubIntegration(t *testing.T) {
defer node.Close() defer node.Close()
// Create PubSub system // Create PubSub system
ps, err := pubsub.NewPubSub(ctx, node.Host(), "bzzz/test/coordination", "hmmm/test/meta-discussion") ps, err := pubsub.NewPubSub(ctx, node.Host(), "CHORUS/test/coordination", "hmmm/test/meta-discussion")
if err != nil { if err != nil {
t.Fatalf("Failed to create PubSub: %v", err) t.Fatalf("Failed to create PubSub: %v", err)
} }
defer ps.Close() defer ps.Close()
// Create adapter using actual BZZZ pubsub methods // Create adapter using actual CHORUS pubsub methods
adapter := NewAdapter( adapter := NewAdapter(
ps.JoinDynamicTopic, ps.JoinDynamicTopic,
ps.PublishRaw, ps.PublishRaw,
) )
// Test publishing to a per-issue topic // Test publishing to a per-issue topic
topic := "bzzz/meta/issue/integration-test-42" topic := "CHORUS/meta/issue/integration-test-42"
testPayload := []byte(`{"version": 1, "type": "meta_msg", "issue_id": 42, "message": "Integration test message"}`) testPayload := []byte(`{"version": 1, "type": "meta_msg", "issue_id": 42, "message": "Integration test message"}`)
err = adapter.Publish(ctx, topic, testPayload) err = adapter.Publish(ctx, topic, testPayload)
@@ -93,7 +93,7 @@ func TestHMMMRouterIntegration(t *testing.T) {
defer node.Close() defer node.Close()
// Create PubSub system // Create PubSub system
ps, err := pubsub.NewPubSub(ctx, node.Host(), "bzzz/test/coordination", "hmmm/test/meta-discussion") ps, err := pubsub.NewPubSub(ctx, node.Host(), "CHORUS/test/coordination", "hmmm/test/meta-discussion")
if err != nil { if err != nil {
t.Fatalf("Failed to create PubSub: %v", err) t.Fatalf("Failed to create PubSub: %v", err)
} }
@@ -158,7 +158,7 @@ func TestPerIssueTopicPublishing(t *testing.T) {
defer node.Close() defer node.Close()
// Create PubSub system // Create PubSub system
ps, err := pubsub.NewPubSub(ctx, node.Host(), "bzzz/test/coordination", "hmmm/test/meta-discussion") ps, err := pubsub.NewPubSub(ctx, node.Host(), "CHORUS/test/coordination", "hmmm/test/meta-discussion")
if err != nil { if err != nil {
t.Fatalf("Failed to create PubSub: %v", err) t.Fatalf("Failed to create PubSub: %v", err)
} }
@@ -238,7 +238,7 @@ func TestConcurrentPerIssuePublishing(t *testing.T) {
defer node.Close() defer node.Close()
// Create PubSub system // Create PubSub system
ps, err := pubsub.NewPubSub(ctx, node.Host(), "bzzz/test/coordination", "hmmm/test/meta-discussion") ps, err := pubsub.NewPubSub(ctx, node.Host(), "CHORUS/test/coordination", "hmmm/test/meta-discussion")
if err != nil { if err != nil {
t.Fatalf("Failed to create PubSub: %v", err) t.Fatalf("Failed to create PubSub: %v", err)
} }
@@ -321,7 +321,7 @@ func TestAdapterValidation(t *testing.T) {
defer node.Close() defer node.Close()
// Create PubSub system // Create PubSub system
ps, err := pubsub.NewPubSub(ctx, node.Host(), "bzzz/test/coordination", "hmmm/test/meta-discussion") ps, err := pubsub.NewPubSub(ctx, node.Host(), "CHORUS/test/coordination", "hmmm/test/meta-discussion")
if err != nil { if err != nil {
t.Fatalf("Failed to create PubSub: %v", err) t.Fatalf("Failed to create PubSub: %v", err)
} }

10
pkg/hmmm_adapter/smoke_test.go
View File

@@ -9,7 +9,7 @@ import (
"time" "time"
) )
// TestPerIssueTopicSmokeTest tests the per-issue topic functionality without full BZZZ integration // TestPerIssueTopicSmokeTest tests the per-issue topic functionality without full CHORUS integration
func TestPerIssueTopicSmokeTest(t *testing.T) { func TestPerIssueTopicSmokeTest(t *testing.T) {
// Mock pubsub functions that track calls // Mock pubsub functions that track calls
joinedTopics := make(map[string]int) joinedTopics := make(map[string]int)
@@ -34,7 +34,7 @@ func TestPerIssueTopicSmokeTest(t *testing.T) {
// Test per-issue topic publishing // Test per-issue topic publishing
issueID := int64(42) issueID := int64(42)
topic := fmt.Sprintf("bzzz/meta/issue/%d", issueID) topic := fmt.Sprintf("CHORUS/meta/issue/%d", issueID)
testMessage := map[string]interface{}{ testMessage := map[string]interface{}{
"version": 1, "version": 1,
@@ -152,7 +152,7 @@ func TestMultiplePerIssueTopics(t *testing.T) {
issueIDs := []int64{100, 200, 300} issueIDs := []int64{100, 200, 300}
for _, issueID := range issueIDs { for _, issueID := range issueIDs {
topic := fmt.Sprintf("bzzz/meta/issue/%d", issueID) topic := fmt.Sprintf("CHORUS/meta/issue/%d", issueID)
testMessage := map[string]interface{}{ testMessage := map[string]interface{}{
"version": 1, "version": 1,
@@ -180,7 +180,7 @@ func TestMultiplePerIssueTopics(t *testing.T) {
// Verify all topics were joined once // Verify all topics were joined once
mu.Lock() mu.Lock()
for _, issueID := range issueIDs { for _, issueID := range issueIDs {
topic := fmt.Sprintf("bzzz/meta/issue/%d", issueID) topic := fmt.Sprintf("CHORUS/meta/issue/%d", issueID)
if joinedTopics[topic] != 1 { if joinedTopics[topic] != 1 {
t.Errorf("Expected topic %s to be joined once, got %d times", topic, joinedTopics[topic]) t.Errorf("Expected topic %s to be joined once, got %d times", topic, joinedTopics[topic])
} }
@@ -258,7 +258,7 @@ func TestHMMMMessageFormat(t *testing.T) {
t.Fatalf("Failed to marshal HMMM message: %v", err) t.Fatalf("Failed to marshal HMMM message: %v", err)
} }
topic := "bzzz/meta/issue/42" topic := "CHORUS/meta/issue/42"
err = adapter.Publish(context.Background(), topic, payload) err = adapter.Publish(context.Background(), topic, payload)
if err != nil { if err != nil {
t.Fatalf("Failed to publish HMMM message: %v", err) t.Fatalf("Failed to publish HMMM message: %v", err)

4
pkg/integration/decision_publisher.go
View File

@@ -8,8 +8,8 @@ import (
"log" "log"
"time" "time"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
) )
// DecisionPublisher handles publishing decisions to encrypted DHT storage // DecisionPublisher handles publishing decisions to encrypted DHT storage

4
pkg/integration/slurp_client.go
View File

@@ -11,7 +11,7 @@ import (
"strings" "strings"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// SlurpClient handles HTTP communication with SLURP endpoints // SlurpClient handles HTTP communication with SLURP endpoints
@@ -150,7 +150,7 @@ func (c *SlurpClient) CreateEventsBatch(ctx context.Context, events []SlurpEvent
batchRequest := BatchEventRequest{ batchRequest := BatchEventRequest{
Events: events, Events: events,
Source: "bzzz-hmmm-integration", Source: "CHORUS-hmmm-integration",
} }
batchData, err := json.Marshal(batchRequest) batchData, err := json.Marshal(batchRequest)

6
pkg/integration/slurp_events.go
View File

@@ -9,9 +9,9 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
) )

2
pkg/integration/slurp_reliable_client.go
View File

@@ -8,7 +8,7 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// ReliableSlurpClient wraps SlurpClient with reliability features // ReliableSlurpClient wraps SlurpClient with reliability features

16
pkg/mcp/server.go
View File

@@ -8,14 +8,14 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/logging" "chorus/internal/logging"
"chorus.services/bzzz/p2p" "chorus/p2p"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
"github.com/gorilla/websocket" "github.com/gorilla/websocket"
"github.com/sashabaranov/go-openai" "github.com/sashabaranov/go-openai"
) )
// McpServer integrates BZZZ P2P network with MCP protocol for GPT-4 agents // McpServer integrates CHORUS P2P network with MCP protocol for GPT-4 agents
type McpServer struct { type McpServer struct {
// Core components // Core components
p2pNode *p2p.Node p2pNode *p2p.Node
@@ -51,7 +51,7 @@ type ServerStats struct {
mutex sync.RWMutex mutex sync.RWMutex
} }
// GPTAgent represents a GPT-4 agent integrated with BZZZ network // GPTAgent represents a GPT-4 agent integrated with CHORUS network
type GPTAgent struct { type GPTAgent struct {
ID string ID string
Role AgentRole Role AgentRole
@@ -310,7 +310,7 @@ func (s *McpServer) CreateGPTAgent(config *AgentConfig) (*GPTAgent, error) {
s.agents[agent.ID] = agent s.agents[agent.ID] = agent
s.agentsMutex.Unlock() s.agentsMutex.Unlock()
// Announce agent to BZZZ network // Announce agent to CHORUS network
if err := s.announceAgent(agent); err != nil { if err := s.announceAgent(agent); err != nil {
return nil, fmt.Errorf("failed to announce agent: %w", err) return nil, fmt.Errorf("failed to announce agent: %w", err)
} }
@@ -485,7 +485,7 @@ func (s *McpServer) handleBzzzAnnounce(args map[string]interface{}) (map[string]
"node_id": s.p2pNode.ID().ShortString(), "node_id": s.p2pNode.ID().ShortString(),
} }
// Publish to BZZZ network // Publish to CHORUS network
if err := s.pubsub.PublishBzzzMessage(pubsub.CapabilityBcast, announcement); err != nil { if err := s.pubsub.PublishBzzzMessage(pubsub.CapabilityBcast, announcement); err != nil {
return nil, fmt.Errorf("failed to announce: %w", err) return nil, fmt.Errorf("failed to announce: %w", err)
} }
@@ -500,7 +500,7 @@ func (s *McpServer) handleBzzzAnnounce(args map[string]interface{}) (map[string]
// Helper methods // Helper methods
// announceAgent announces an agent to the BZZZ network // announceAgent announces an agent to the CHORUS network
func (s *McpServer) announceAgent(agent *GPTAgent) error { func (s *McpServer) announceAgent(agent *GPTAgent) error {
announcement := map[string]interface{}{ announcement := map[string]interface{}{
"type": "gpt_agent_announcement", "type": "gpt_agent_announcement",

2
pkg/metrics/prometheus_metrics.go
View File

@@ -13,7 +13,7 @@ import (
"github.com/prometheus/client_golang/prometheus/promauto" "github.com/prometheus/client_golang/prometheus/promauto"
) )
// BZZZMetrics provides comprehensive Prometheus metrics for the BZZZ system // BZZZMetrics provides comprehensive Prometheus metrics for the CHORUS system
type BZZZMetrics struct { type BZZZMetrics struct {
registry *prometheus.Registry registry *prometheus.Registry
httpServer *http.Server httpServer *http.Server

18
pkg/protocol/integration.go
View File

@@ -7,13 +7,13 @@ import (
"strings" "strings"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/p2p" "chorus/p2p"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
) )
// ProtocolManager manages the BZZZ v2 protocol components // ProtocolManager manages the CHORUS v2 protocol components
type ProtocolManager struct { type ProtocolManager struct {
config *config.Config config *config.Config
node *p2p.Node node *p2p.Node
@@ -97,7 +97,7 @@ func (pm *ProtocolManager) IsEnabled() bool {
return pm.enabled return pm.enabled
} }
// ResolveURI resolves a bzzz:// URI to peer addresses // ResolveURI resolves a CHORUS:// URI to peer addresses
func (pm *ProtocolManager) ResolveURI(ctx context.Context, uriStr string) (*ResolutionResult, error) { func (pm *ProtocolManager) ResolveURI(ctx context.Context, uriStr string) (*ResolutionResult, error) {
if !pm.enabled { if !pm.enabled {
return nil, fmt.Errorf("v2 protocol not enabled") return nil, fmt.Errorf("v2 protocol not enabled")
@@ -205,7 +205,7 @@ func (pm *ProtocolManager) announcePeerToDHT(ctx context.Context, capability *Pe
} }
// Announce general peer presence // Announce general peer presence
if err := dht.Provide(ctx, "bzzz:peer"); err != nil { if err := dht.Provide(ctx, "CHORUS:peer"); err != nil {
// Log error but don't fail // Log error but don't fail
} }
@@ -249,7 +249,7 @@ func (pm *ProtocolManager) FindPeersByRole(ctx context.Context, role string) ([]
return result, nil return result, nil
} }
// ValidateURI validates a bzzz:// URI // ValidateURI validates a CHORUS:// URI
func (pm *ProtocolManager) ValidateURI(uriStr string) error { func (pm *ProtocolManager) ValidateURI(uriStr string) error {
if !pm.enabled { if !pm.enabled {
return fmt.Errorf("v2 protocol not enabled") return fmt.Errorf("v2 protocol not enabled")
@@ -259,7 +259,7 @@ func (pm *ProtocolManager) ValidateURI(uriStr string) error {
return err return err
} }
// CreateURI creates a bzzz:// URI with the given components // CreateURI creates a CHORUS:// URI with the given components
func (pm *ProtocolManager) CreateURI(agent, role, project, task, path string) (*BzzzURI, error) { func (pm *ProtocolManager) CreateURI(agent, role, project, task, path string) (*BzzzURI, error) {
if !pm.enabled { if !pm.enabled {
return nil, fmt.Errorf("v2 protocol not enabled") return nil, fmt.Errorf("v2 protocol not enabled")
@@ -313,7 +313,7 @@ func (pm *ProtocolManager) getProjectFromConfig() string {
} }
// Default project if none can be inferred // Default project if none can be inferred
return "bzzz" return "CHORUS"
} }
// GetStats returns protocol statistics // GetStats returns protocol statistics

4
pkg/protocol/resolver.go
View File

@@ -151,7 +151,7 @@ func (r *Resolver) UpdatePeerStatus(peerID peer.ID, status string) {
} }
} }
// Resolve resolves a bzzz:// URI to peer addresses // Resolve resolves a CHORUS:// URI to peer addresses
func (r *Resolver) Resolve(ctx context.Context, uri *BzzzURI, strategy ...ResolutionStrategy) (*ResolutionResult, error) { func (r *Resolver) Resolve(ctx context.Context, uri *BzzzURI, strategy ...ResolutionStrategy) (*ResolutionResult, error) {
if uri == nil { if uri == nil {
return nil, fmt.Errorf("nil URI") return nil, fmt.Errorf("nil URI")
@@ -181,7 +181,7 @@ func (r *Resolver) Resolve(ctx context.Context, uri *BzzzURI, strategy ...Resolu
return result, nil return result, nil
} }
// ResolveString resolves a bzzz:// URI string to peer addresses // ResolveString resolves a CHORUS:// URI string to peer addresses
func (r *Resolver) ResolveString(ctx context.Context, uriStr string, strategy ...ResolutionStrategy) (*ResolutionResult, error) { func (r *Resolver) ResolveString(ctx context.Context, uriStr string, strategy ...ResolutionStrategy) (*ResolutionResult, error) {
uri, err := ParseBzzzURI(uriStr) uri, err := ParseBzzzURI(uriStr)
if err != nil { if err != nil {

12
pkg/protocol/resolver_test.go
View File

@@ -155,7 +155,7 @@ func TestResolveURI(t *testing.T) {
}) })
// Test exact match // Test exact match
uri, err := ParseBzzzURI("bzzz://claude:frontend@chorus:react") uri, err := ParseBzzzURI("CHORUS://claude:frontend@chorus:react")
if err != nil { if err != nil {
t.Fatalf("failed to parse URI: %v", err) t.Fatalf("failed to parse URI: %v", err)
} }
@@ -196,7 +196,7 @@ func TestResolveURIWithWildcards(t *testing.T) {
}) })
// Test wildcard match // Test wildcard match
uri, err := ParseBzzzURI("bzzz://claude:*@*:*") uri, err := ParseBzzzURI("CHORUS://claude:*@*:*")
if err != nil { if err != nil {
t.Fatalf("failed to parse URI: %v", err) t.Fatalf("failed to parse URI: %v", err)
} }
@@ -223,7 +223,7 @@ func TestResolveURIWithOfflinePeers(t *testing.T) {
Status: "offline", // This peer should be filtered out Status: "offline", // This peer should be filtered out
}) })
uri, err := ParseBzzzURI("bzzz://claude:frontend@*:*") uri, err := ParseBzzzURI("CHORUS://claude:frontend@*:*")
if err != nil { if err != nil {
t.Fatalf("failed to parse URI: %v", err) t.Fatalf("failed to parse URI: %v", err)
} }
@@ -250,7 +250,7 @@ func TestResolveString(t *testing.T) {
}) })
ctx := context.Background() ctx := context.Background()
result, err := resolver.ResolveString(ctx, "bzzz://claude:frontend@*:*") result, err := resolver.ResolveString(ctx, "CHORUS://claude:frontend@*:*")
if err != nil { if err != nil {
t.Fatalf("failed to resolve string: %v", err) t.Fatalf("failed to resolve string: %v", err)
} }
@@ -271,7 +271,7 @@ func TestResolverCaching(t *testing.T) {
}) })
ctx := context.Background() ctx := context.Background()
uri := "bzzz://claude:frontend@*:*" uri := "CHORUS://claude:frontend@*:*"
// First resolution should hit the resolver // First resolution should hit the resolver
result1, err := resolver.ResolveString(ctx, uri) result1, err := resolver.ResolveString(ctx, uri)
@@ -324,7 +324,7 @@ func TestResolutionStrategies(t *testing.T) {
}) })
ctx := context.Background() ctx := context.Background()
uri, _ := ParseBzzzURI("bzzz://claude:frontend@*:*") uri, _ := ParseBzzzURI("CHORUS://claude:frontend@*:*")
// Test different strategies // Test different strategies
strategies := []ResolutionStrategy{ strategies := []ResolutionStrategy{

16
pkg/protocol/uri.go
View File

@@ -7,13 +7,13 @@ import (
"strings" "strings"
) )
// BzzzURI represents a parsed bzzz:// URI with semantic addressing // BzzzURI represents a parsed CHORUS:// URI with semantic addressing
// Grammar: bzzz://[agent]:[role]@[project]:[task]/[path][?query][#fragment] // Grammar: CHORUS://[agent]:[role]@[project]:[task]/[path][?query][#fragment]
type BzzzURI struct { type BzzzURI struct {
// Core addressing components // Core addressing components
Agent string // Agent identifier (e.g., "claude", "any", "*") Agent string // Agent identifier (e.g., "claude", "any", "*")
Role string // Agent role (e.g., "frontend", "backend", "architect") Role string // Agent role (e.g., "frontend", "backend", "architect")
Project string // Project context (e.g., "chorus", "bzzz") Project string // Project context (e.g., "chorus", "CHORUS")
Task string // Task identifier (e.g., "implement", "review", "test", "*") Task string // Task identifier (e.g., "implement", "review", "test", "*")
// Resource path // Resource path
@@ -29,7 +29,7 @@ type BzzzURI struct {
// URI grammar constants // URI grammar constants
const ( const (
BzzzScheme = "bzzz" BzzzScheme = "CHORUS"
// Special identifiers // Special identifiers
AnyAgent = "any" AnyAgent = "any"
@@ -49,10 +49,10 @@ var (
pathPattern = regexp.MustCompile(`^/[a-zA-Z0-9\-_/\.]*$|^$`) pathPattern = regexp.MustCompile(`^/[a-zA-Z0-9\-_/\.]*$|^$`)
// Full URI pattern for validation // Full URI pattern for validation
bzzzURIPattern = regexp.MustCompile(`^bzzz://([a-zA-Z0-9\-_*]|any):([a-zA-Z0-9\-_*]|any)@([a-zA-Z0-9\-_*]|any):([a-zA-Z0-9\-_*]|any)(/[a-zA-Z0-9\-_/\.]*)?(\?[^#]*)?(\#.*)?$`) bzzzURIPattern = regexp.MustCompile(`^CHORUS://([a-zA-Z0-9\-_*]|any):([a-zA-Z0-9\-_*]|any)@([a-zA-Z0-9\-_*]|any):([a-zA-Z0-9\-_*]|any)(/[a-zA-Z0-9\-_/\.]*)?(\?[^#]*)?(\#.*)?$`)
) )
// ParseBzzzURI parses a bzzz:// URI string into a BzzzURI struct // ParseBzzzURI parses a CHORUS:// URI string into a BzzzURI struct
func ParseBzzzURI(uri string) (*BzzzURI, error) { func ParseBzzzURI(uri string) (*BzzzURI, error) {
if uri == "" { if uri == "" {
return nil, fmt.Errorf("empty URI") return nil, fmt.Errorf("empty URI")
@@ -292,14 +292,14 @@ func (u *BzzzURI) ToAddress() string {
return fmt.Sprintf("%s:%s@%s:%s", u.Agent, u.Role, u.Project, u.Task) return fmt.Sprintf("%s:%s@%s:%s", u.Agent, u.Role, u.Project, u.Task)
} }
// ValidateBzzzURIString validates a bzzz:// URI string without parsing // ValidateBzzzURIString validates a CHORUS:// URI string without parsing
func ValidateBzzzURIString(uri string) error { func ValidateBzzzURIString(uri string) error {
if uri == "" { if uri == "" {
return fmt.Errorf("empty URI") return fmt.Errorf("empty URI")
} }
if !bzzzURIPattern.MatchString(uri) { if !bzzzURIPattern.MatchString(uri) {
return fmt.Errorf("invalid bzzz:// URI format") return fmt.Errorf("invalid CHORUS:// URI format")
} }
return nil return nil

34
pkg/protocol/uri_test.go
View File

@@ -13,50 +13,50 @@ func TestParseBzzzURI(t *testing.T) {
}{ }{
{ {
name: "valid basic URI", name: "valid basic URI",
uri: "bzzz://claude:frontend@chorus:implement/src/main.go", uri: "CHORUS://claude:frontend@chorus:implement/src/main.go",
expected: &BzzzURI{ expected: &BzzzURI{
Agent: "claude", Agent: "claude",
Role: "frontend", Role: "frontend",
Project: "chorus", Project: "chorus",
Task: "implement", Task: "implement",
Path: "/src/main.go", Path: "/src/main.go",
Raw: "bzzz://claude:frontend@chorus:implement/src/main.go", Raw: "CHORUS://claude:frontend@chorus:implement/src/main.go",
}, },
}, },
{ {
name: "URI with wildcards", name: "URI with wildcards",
uri: "bzzz://any:*@*:test", uri: "CHORUS://any:*@*:test",
expected: &BzzzURI{ expected: &BzzzURI{
Agent: "any", Agent: "any",
Role: "*", Role: "*",
Project: "*", Project: "*",
Task: "test", Task: "test",
Raw: "bzzz://any:*@*:test", Raw: "CHORUS://any:*@*:test",
}, },
}, },
{ {
name: "URI with query and fragment", name: "URI with query and fragment",
uri: "bzzz://claude:backend@bzzz:debug/api/handler.go?type=error#line123", uri: "CHORUS://claude:backend@CHORUS:debug/api/handler.go?type=error#line123",
expected: &BzzzURI{ expected: &BzzzURI{
Agent: "claude", Agent: "claude",
Role: "backend", Role: "backend",
Project: "bzzz", Project: "CHORUS",
Task: "debug", Task: "debug",
Path: "/api/handler.go", Path: "/api/handler.go",
Query: "type=error", Query: "type=error",
Fragment: "line123", Fragment: "line123",
Raw: "bzzz://claude:backend@bzzz:debug/api/handler.go?type=error#line123", Raw: "CHORUS://claude:backend@CHORUS:debug/api/handler.go?type=error#line123",
}, },
}, },
{ {
name: "URI without path", name: "URI without path",
uri: "bzzz://any:architect@project:review", uri: "CHORUS://any:architect@project:review",
expected: &BzzzURI{ expected: &BzzzURI{
Agent: "any", Agent: "any",
Role: "architect", Role: "architect",
Project: "project", Project: "project",
Task: "review", Task: "review",
Raw: "bzzz://any:architect@project:review", Raw: "CHORUS://any:architect@project:review",
}, },
}, },
{ {
@@ -66,12 +66,12 @@ func TestParseBzzzURI(t *testing.T) {
}, },
{ {
name: "missing role", name: "missing role",
uri: "bzzz://claude@chorus:implement", uri: "CHORUS://claude@chorus:implement",
expectError: true, expectError: true,
}, },
{ {
name: "missing task", name: "missing task",
uri: "bzzz://claude:frontend@chorus", uri: "CHORUS://claude:frontend@chorus",
expectError: true, expectError: true,
}, },
{ {
@@ -81,7 +81,7 @@ func TestParseBzzzURI(t *testing.T) {
}, },
{ {
name: "invalid format", name: "invalid format",
uri: "bzzz://invalid", uri: "CHORUS://invalid",
expectError: true, expectError: true,
}, },
} }
@@ -307,20 +307,20 @@ func TestBzzzURIString(t *testing.T) {
Task: "implement", Task: "implement",
Path: "/src/main.go", Path: "/src/main.go",
}, },
expected: "bzzz://claude:frontend@chorus:implement/src/main.go", expected: "CHORUS://claude:frontend@chorus:implement/src/main.go",
}, },
{ {
name: "URI with query and fragment", name: "URI with query and fragment",
uri: &BzzzURI{ uri: &BzzzURI{
Agent: "claude", Agent: "claude",
Role: "backend", Role: "backend",
Project: "bzzz", Project: "CHORUS",
Task: "debug", Task: "debug",
Path: "/api/handler.go", Path: "/api/handler.go",
Query: "type=error", Query: "type=error",
Fragment: "line123", Fragment: "line123",
}, },
expected: "bzzz://claude:backend@bzzz:debug/api/handler.go?type=error#line123", expected: "CHORUS://claude:backend@CHORUS:debug/api/handler.go?type=error#line123",
}, },
{ {
name: "URI without path", name: "URI without path",
@@ -330,7 +330,7 @@ func TestBzzzURIString(t *testing.T) {
Project: "project", Project: "project",
Task: "review", Task: "review",
}, },
expected: "bzzz://any:architect@project:review", expected: "CHORUS://any:architect@project:review",
}, },
} }
@@ -479,7 +479,7 @@ func TestValidateBzzzURIString(t *testing.T) {
}{ }{
{ {
name: "valid URI", name: "valid URI",
uri: "bzzz://claude:frontend@chorus:implement/src/main.go", uri: "CHORUS://claude:frontend@chorus:implement/src/main.go",
expectError: false, expectError: false,
}, },
{ {

199
pkg/repository/types.go Normal file
View File

@@ -0,0 +1,199 @@
package repository
import (
"time"
)
// Task represents a task from a repository (GitHub issue, GitLab MR, etc.)
type Task struct {
Number int `json:"number"`
Title string `json:"title"`
Body string `json:"body"`
Repository string `json:"repository"`
Labels []string `json:"labels"`
Priority int `json:"priority"`
Complexity int `json:"complexity"`
Status string `json:"status"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
Metadata map[string]interface{} `json:"metadata"`
RequiredRole string `json:"required_role"`
RequiredExpertise []string `json:"required_expertise"`
}
// TaskProvider interface for different repository providers (GitHub, GitLab, etc.)
type TaskProvider interface {
GetTasks(projectID int) ([]*Task, error)
ClaimTask(taskNumber int, agentID string) (bool, error)
UpdateTaskStatus(task *Task, status string, comment string) error
CompleteTask(task *Task, result *TaskResult) error
GetTaskDetails(projectID int, taskNumber int) (*Task, error)
ListAvailableTasks(projectID int) ([]*Task, error)
}
// TaskMatcher determines if an agent should work on a task
type TaskMatcher interface {
ShouldProcessTask(task *Task, agentInfo *AgentInfo) bool
CalculateTaskPriority(task *Task, agentInfo *AgentInfo) int
ScoreTaskForAgent(task *Task, agentInfo *AgentInfo) float64
}
// ProviderFactory creates task providers for different repository types
type ProviderFactory interface {
CreateProvider(ctx interface{}, config *Config) (TaskProvider, error)
GetSupportedTypes() []string
SupportedProviders() []string
}
// AgentInfo represents information about the current agent
type AgentInfo struct {
ID string `json:"id"`
Role string `json:"role"`
Expertise []string `json:"expertise"`
Capabilities []string `json:"capabilities"`
MaxTasks int `json:"max_tasks"`
CurrentTasks int `json:"current_tasks"`
Status string `json:"status"`
LastSeen time.Time `json:"last_seen"`
Performance map[string]interface{} `json:"performance"`
Availability string `json:"availability"`
}
// TaskResult represents the result of completing a task
type TaskResult struct {
Success bool `json:"success"`
Message string `json:"message"`
Artifacts []string `json:"artifacts"`
Duration time.Duration `json:"duration"`
Metadata map[string]interface{} `json:"metadata"`
}
// Config represents repository configuration
type Config struct {
Type string `json:"type"`
Settings map[string]interface{} `json:"settings"`
Provider string `json:"provider"`
BaseURL string `json:"base_url"`
AccessToken string `json:"access_token"`
Owner string `json:"owner"`
Repository string `json:"repository"`
TaskLabel string `json:"task_label"`
InProgressLabel string `json:"in_progress_label"`
CompletedLabel string `json:"completed_label"`
BaseBranch string `json:"base_branch"`
BranchPrefix string `json:"branch_prefix"`
}
// DefaultTaskMatcher provides a default implementation of TaskMatcher
type DefaultTaskMatcher struct{}
// ShouldProcessTask determines if an agent should process a task
func (m *DefaultTaskMatcher) ShouldProcessTask(task *Task, agentInfo *AgentInfo) bool {
// Simple logic: check if agent has capacity and matching expertise
if agentInfo.CurrentTasks >= agentInfo.MaxTasks {
return false
}
// Check if any of agent's expertise matches task labels
for _, expertise := range agentInfo.Expertise {
for _, label := range task.Labels {
if expertise == label {
return true
}
}
}
// Default to true for general tasks
return len(task.Labels) == 0 || task.Priority > 5
}
// CalculateTaskPriority calculates priority score for a task
func (m *DefaultTaskMatcher) CalculateTaskPriority(task *Task, agentInfo *AgentInfo) int {
priority := task.Priority
// Boost priority for tasks matching expertise
for _, expertise := range agentInfo.Expertise {
for _, label := range task.Labels {
if expertise == label {
priority += 2
break
}
}
}
return priority
}
// ScoreTaskForAgent calculates a score for how well an agent matches a task
func (m *DefaultTaskMatcher) ScoreTaskForAgent(task *Task, agentInfo *AgentInfo) float64 {
score := float64(task.Priority) / 10.0
// Boost score for matching expertise
matchCount := 0
for _, expertise := range agentInfo.Expertise {
for _, label := range task.Labels {
if expertise == label {
matchCount++
break
}
}
}
if len(agentInfo.Expertise) > 0 {
score += (float64(matchCount) / float64(len(agentInfo.Expertise))) * 0.5
}
return score
}
// DefaultProviderFactory provides a default implementation of ProviderFactory
type DefaultProviderFactory struct{}
// CreateProvider creates a task provider (stub implementation)
func (f *DefaultProviderFactory) CreateProvider(ctx interface{}, config *Config) (TaskProvider, error) {
// In a real implementation, this would create GitHub, GitLab, etc. providers
return &MockTaskProvider{}, nil
}
// GetSupportedTypes returns supported repository types
func (f *DefaultProviderFactory) GetSupportedTypes() []string {
return []string{"github", "gitlab", "mock"}
}
// SupportedProviders returns list of supported providers
func (f *DefaultProviderFactory) SupportedProviders() []string {
return f.GetSupportedTypes()
}
// MockTaskProvider provides a mock implementation for testing
type MockTaskProvider struct{}
// GetTasks returns mock tasks
func (p *MockTaskProvider) GetTasks(projectID int) ([]*Task, error) {
return []*Task{}, nil
}
// ClaimTask claims a task
func (p *MockTaskProvider) ClaimTask(taskNumber int, agentID string) (bool, error) {
return true, nil
}
// UpdateTaskStatus updates task status
func (p *MockTaskProvider) UpdateTaskStatus(task *Task, status string, comment string) error {
return nil
}
// CompleteTask completes a task
func (p *MockTaskProvider) CompleteTask(task *Task, result *TaskResult) error {
return nil
}
// GetTaskDetails gets task details
func (p *MockTaskProvider) GetTaskDetails(projectID int, taskNumber int) (*Task, error) {
return &Task{}, nil
}
// ListAvailableTasks lists available tasks
func (p *MockTaskProvider) ListAvailableTasks(projectID int) ([]*Task, error) {
return []*Task{}, nil
}

2
pkg/security/access_levels.go
View File

@@ -1,4 +1,4 @@
// Package security provides shared security types and constants for BZZZ // Package security provides shared security types and constants for CHORUS
// This package contains common security definitions that are used by both // This package contains common security definitions that are used by both
// the crypto and slurp/roles packages to avoid circular dependencies. // the crypto and slurp/roles packages to avoid circular dependencies.

4
pkg/slurp/alignment/interfaces.go
View File

@@ -4,8 +4,8 @@ import (
"context" "context"
"time" "time"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// GoalManager handles definition and management of project goals // GoalManager handles definition and management of project goals

4
pkg/slurp/alignment/types.go
View File

@@ -3,8 +3,8 @@ package alignment
import ( import (
"time" "time"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// ProjectGoal represents a high-level project objective // ProjectGoal represents a high-level project objective

6
pkg/slurp/context/doc.go
View File

@@ -1,7 +1,7 @@
// Package context provides core context types and interfaces for the SLURP contextual intelligence system. // Package context provides core context types and interfaces for the SLURP contextual intelligence system.
// //
// This package defines the foundational data structures and interfaces for hierarchical // This package defines the foundational data structures and interfaces for hierarchical
// context resolution within the BZZZ distributed AI development system. It implements // context resolution within the CHORUS distributed AI development system. It implements
// bounded hierarchy traversal with role-based access control for efficient context // bounded hierarchy traversal with role-based access control for efficient context
// resolution and caching. // resolution and caching.
// //
@@ -10,7 +10,7 @@
// - Role-based access control and encryption for context data // - Role-based access control and encryption for context data
// - CSS-like inheritance patterns for cascading context properties // - CSS-like inheritance patterns for cascading context properties
// - Efficient caching with selective invalidation // - Efficient caching with selective invalidation
// - Integration with BZZZ election system for leader-only generation // - Integration with CHORUS election system for leader-only generation
// //
// Core Types: // Core Types:
// - ContextNode: Represents a single context entry in the hierarchy // - ContextNode: Represents a single context entry in the hierarchy
@@ -60,5 +60,5 @@
// All context data is encrypted based on role access levels before storage // All context data is encrypted based on role access levels before storage
// in the distributed DHT. Only nodes with appropriate role permissions can // in the distributed DHT. Only nodes with appropriate role permissions can
// decrypt and access context information, ensuring secure context sharing // decrypt and access context information, ensuring secure context sharing
// across the BZZZ cluster. // across the CHORUS cluster.
package context package context

6
pkg/slurp/context/resolver.go
View File

@@ -5,8 +5,8 @@ import (
"fmt" "fmt"
"time" "time"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// ContextResolver defines the interface for hierarchical context resolution // ContextResolver defines the interface for hierarchical context resolution
@@ -437,7 +437,7 @@ Integration Examples:
4. Complete Resolution Flow Example: 4. Complete Resolution Flow Example:
// Resolve context with full BZZZ integration // Resolve context with full CHORUS integration
func (resolver *DefaultContextResolver) ResolveWithIntegration(ctx context.Context, address ucxl.Address, role string, maxDepth int) (*ResolvedContext, error) { func (resolver *DefaultContextResolver) ResolveWithIntegration(ctx context.Context, address ucxl.Address, role string, maxDepth int) (*ResolvedContext, error) {
// 1. Validate request // 1. Validate request
if err := ValidateContextResolutionRequest(address, role, maxDepth); err != nil { if err := ValidateContextResolutionRequest(address, role, maxDepth); err != nil {

4
pkg/slurp/context/types.go
View File

@@ -4,8 +4,8 @@ import (
"fmt" "fmt"
"time" "time"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// ContextNode represents a hierarchical context node in the SLURP system. // ContextNode represents a hierarchical context node in the SLURP system.

12
pkg/slurp/distribution/coordinator.go
View File

@@ -7,12 +7,12 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/crypto" "chorus/pkg/crypto"
"chorus.services/bzzz/pkg/election" "chorus/pkg/election"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// DistributionCoordinator orchestrates distributed context operations across the cluster // DistributionCoordinator orchestrates distributed context operations across the cluster

14
pkg/slurp/distribution/dht.go
View File

@@ -9,17 +9,17 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/crypto" "chorus/pkg/crypto"
"chorus.services/bzzz/pkg/election" "chorus/pkg/election"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// ContextDistributor handles distributed context operations via DHT // ContextDistributor handles distributed context operations via DHT
// //
// This is the primary interface for distributing context data across the BZZZ // This is the primary interface for distributing context data across the CHORUS
// cluster using the existing DHT infrastructure with role-based encryption // cluster using the existing DHT infrastructure with role-based encryption
// and conflict resolution capabilities. // and conflict resolution capabilities.
type ContextDistributor interface { type ContextDistributor interface {

16
pkg/slurp/distribution/dht_impl.go
View File

@@ -10,15 +10,15 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/crypto" "chorus/pkg/crypto"
"chorus.services/bzzz/pkg/election" "chorus/pkg/election"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// DHTContextDistributor implements ContextDistributor using BZZZ DHT infrastructure // DHTContextDistributor implements ContextDistributor using CHORUS DHT infrastructure
type DHTContextDistributor struct { type DHTContextDistributor struct {
mu sync.RWMutex mu sync.RWMutex
dht *dht.DHT dht *dht.DHT
@@ -52,7 +52,7 @@ func NewDHTContextDistributor(
return nil, fmt.Errorf("config is required") return nil, fmt.Errorf("config is required")
} }
deploymentID := fmt.Sprintf("bzzz-slurp-%s", config.Agent.ID) deploymentID := fmt.Sprintf("CHORUS-slurp-%s", config.Agent.ID)
dist := &DHTContextDistributor{ dist := &DHTContextDistributor{
dht: dht, dht: dht,

6
pkg/slurp/distribution/doc.go
View File

@@ -1,6 +1,6 @@
// Package distribution provides context network distribution capabilities via DHT integration. // Package distribution provides context network distribution capabilities via DHT integration.
// //
// This package implements distributed context sharing across the BZZZ cluster using // This package implements distributed context sharing across the CHORUS cluster using
// the existing Distributed Hash Table (DHT) infrastructure. It provides role-based // the existing Distributed Hash Table (DHT) infrastructure. It provides role-based
// encrypted distribution, conflict resolution, and eventual consistency for context // encrypted distribution, conflict resolution, and eventual consistency for context
// data synchronization across multiple nodes. // data synchronization across multiple nodes.
@@ -23,7 +23,7 @@
// - NetworkManager: Network topology and partition handling // - NetworkManager: Network topology and partition handling
// //
// Integration Points: // Integration Points:
// - pkg/dht: Existing BZZZ DHT infrastructure // - pkg/dht: Existing CHORUS DHT infrastructure
// - pkg/crypto: Role-based encryption and decryption // - pkg/crypto: Role-based encryption and decryption
// - pkg/election: Leader coordination for conflict resolution // - pkg/election: Leader coordination for conflict resolution
// - pkg/slurp/context: Context types and validation // - pkg/slurp/context: Context types and validation
@@ -67,7 +67,7 @@
// //
// Security Model: // Security Model:
// All context data is encrypted before distribution using role-specific keys // All context data is encrypted before distribution using role-specific keys
// from the BZZZ crypto system. Only nodes with appropriate role permissions // from the CHORUS crypto system. Only nodes with appropriate role permissions
// can decrypt and access context information, ensuring secure collaborative // can decrypt and access context information, ensuring secure collaborative
// development while maintaining access control boundaries. // development while maintaining access control boundaries.
// //

6
pkg/slurp/distribution/gossip.go
View File

@@ -9,9 +9,9 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
) )
// GossipProtocolImpl implements GossipProtocol interface for metadata synchronization // GossipProtocolImpl implements GossipProtocol interface for metadata synchronization

6
pkg/slurp/distribution/monitoring.go
View File

@@ -10,7 +10,7 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// MonitoringSystem provides comprehensive monitoring for the distributed context system // MonitoringSystem provides comprehensive monitoring for the distributed context system
@@ -1075,9 +1075,9 @@ func (ms *MonitoringSystem) handleDashboard(w http.ResponseWriter, r *http.Reque
html := ` html := `
<!DOCTYPE html> <!DOCTYPE html>
<html> <html>
<head><title>BZZZ SLURP Monitoring</title></head> <head><title>CHORUS SLURP Monitoring</title></head>
<body> <body>
<h1>BZZZ SLURP Distributed Context Monitoring</h1> <h1>CHORUS SLURP Distributed Context Monitoring</h1>
<p>Monitoring dashboard placeholder</p> <p>Monitoring dashboard placeholder</p>
</body> </body>
</html> </html>

4
pkg/slurp/distribution/network.go
View File

@@ -9,8 +9,8 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
) )

6
pkg/slurp/distribution/replication.go
View File

@@ -7,9 +7,9 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
"github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/peer"
) )

6
pkg/slurp/distribution/security.go
View File

@@ -14,8 +14,8 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/crypto" "chorus/pkg/crypto"
) )
// SecurityManager handles all security aspects of the distributed system // SecurityManager handles all security aspects of the distributed system
@@ -653,7 +653,7 @@ func (sm *SecurityManager) generateSelfSignedCertificate() ([]byte, []byte, erro
template := x509.Certificate{ template := x509.Certificate{
SerialNumber: big.NewInt(1), SerialNumber: big.NewInt(1),
Subject: pkix.Name{ Subject: pkix.Name{
Organization: []string{"BZZZ SLURP"}, Organization: []string{"CHORUS SLURP"},
Country: []string{"US"}, Country: []string{"US"},
Province: []string{""}, Province: []string{""},
Locality: []string{"San Francisco"}, Locality: []string{"San Francisco"},

4
pkg/slurp/intelligence/directory_analyzer.go
View File

@@ -11,8 +11,8 @@ import (
"strings" "strings"
"time" "time"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// DefaultDirectoryAnalyzer provides comprehensive directory structure analysis // DefaultDirectoryAnalyzer provides comprehensive directory structure analysis

2
pkg/slurp/intelligence/doc.go
View File

@@ -47,7 +47,7 @@
// fmt.Printf("Role insights: %v\n", insights) // fmt.Printf("Role insights: %v\n", insights)
// //
// Leadership Integration: // Leadership Integration:
// This package is designed to be used primarily by the elected BZZZ leader node, // This package is designed to be used primarily by the elected CHORUS leader node,
// which has the responsibility for context generation across the cluster. The // which has the responsibility for context generation across the cluster. The
// intelligence engine coordinates with the leader election system to ensure // intelligence engine coordinates with the leader election system to ensure
// only authorized nodes perform context generation operations. // only authorized nodes perform context generation operations.

4
pkg/slurp/intelligence/engine.go
View File

@@ -4,8 +4,8 @@ import (
"context" "context"
"time" "time"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// IntelligenceEngine provides AI-powered context analysis and generation // IntelligenceEngine provides AI-powered context analysis and generation

4
pkg/slurp/intelligence/engine_impl.go
View File

@@ -10,8 +10,8 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// AnalyzeFile analyzes a single file and generates contextual understanding // AnalyzeFile analyzes a single file and generates contextual understanding

2
pkg/slurp/intelligence/engine_test.go
View File

@@ -7,7 +7,7 @@ import (
"testing" "testing"
"time" "time"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
func TestIntelligenceEngine_Integration(t *testing.T) { func TestIntelligenceEngine_Integration(t *testing.T) {

2
pkg/slurp/intelligence/goal_alignment.go
View File

@@ -9,7 +9,7 @@ import (
"sync" "sync"
"time" "time"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// GoalAlignmentEngine provides comprehensive goal alignment assessment // GoalAlignmentEngine provides comprehensive goal alignment assessment

2
pkg/slurp/intelligence/pattern_detector.go
View File

@@ -9,7 +9,7 @@ import (
"strings" "strings"
"time" "time"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// DefaultPatternDetector provides comprehensive pattern detection capabilities // DefaultPatternDetector provides comprehensive pattern detection capabilities

2
pkg/slurp/intelligence/rag_integration.go
View File

@@ -11,7 +11,7 @@ import (
"sync" "sync"
"time" "time"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// DefaultRAGIntegration provides comprehensive RAG system integration // DefaultRAGIntegration provides comprehensive RAG system integration

4
pkg/slurp/intelligence/role_aware_processor.go
View File

@@ -8,8 +8,8 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/crypto" "chorus/pkg/crypto"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// RoleAwareProcessor provides role-based context processing and insight generation // RoleAwareProcessor provides role-based context processing and insight generation

2
pkg/slurp/intelligence/utils.go
View File

@@ -16,7 +16,7 @@ import (
"strings" "strings"
"time" "time"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// Utility functions and helper types for the intelligence engine // Utility functions and helper types for the intelligence engine

2
pkg/slurp/interfaces.go
View File

@@ -229,7 +229,7 @@ type DecisionNavigator interface {
// DistributedStorage handles distributed storage of context data. // DistributedStorage handles distributed storage of context data.
// //
// Provides encrypted, role-based storage using the existing BZZZ DHT // Provides encrypted, role-based storage using the existing CHORUS DHT
// infrastructure with consistency guarantees and conflict resolution. // infrastructure with consistency guarantees and conflict resolution.
type DistributedStorage interface { type DistributedStorage interface {
// Store stores context data in the DHT with encryption. // Store stores context data in the DHT with encryption.

10
pkg/slurp/leader/config.go
View File

@@ -6,7 +6,7 @@ import (
"strconv" "strconv"
"strings" "strings"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
) )
// SLURPLeaderConfig represents comprehensive configuration for SLURP-enabled leader election // SLURPLeaderConfig represents comprehensive configuration for SLURP-enabled leader election
@@ -280,7 +280,7 @@ func DefaultSLURPLeaderConfig() *SLURPLeaderConfig {
return &SLURPLeaderConfig{ return &SLURPLeaderConfig{
Core: &CoreConfig{ Core: &CoreConfig{
NodeID: "", // Will be auto-generated NodeID: "", // Will be auto-generated
ClusterID: "bzzz-cluster", ClusterID: "CHORUS-cluster",
DataDirectory: "./data", DataDirectory: "./data",
Capabilities: []string{"admin_election", "context_curation", "project_manager"}, Capabilities: []string{"admin_election", "context_curation", "project_manager"},
ProjectManagerEnabled: true, ProjectManagerEnabled: true,
@@ -579,11 +579,11 @@ func (cfg *SLURPLeaderConfig) GetEffectiveConfig() *SLURPLeaderConfig {
return &effective return &effective
} }
// ToBaseBZZZConfig converts SLURP leader config to base BZZZ config format // ToBaseBZZZConfig converts SLURP leader config to base CHORUS config format
func (cfg *SLURPLeaderConfig) ToBaseBZZZConfig() *config.Config { func (cfg *SLURPLeaderConfig) ToBaseBZZZConfig() *config.Config {
// TODO: Convert to base BZZZ config structure // TODO: Convert to base CHORUS config structure
// This would map SLURP-specific configuration to the existing // This would map SLURP-specific configuration to the existing
// BZZZ configuration structure for compatibility // CHORUS configuration structure for compatibility
bzzzConfig := &config.Config{ bzzzConfig := &config.Config{
// Map core settings // Map core settings

8
pkg/slurp/leader/doc.go
View File

@@ -1,9 +1,9 @@
// Package leader provides leader-specific context management duties for the SLURP system. // Package leader provides leader-specific context management duties for the SLURP system.
// //
// This package implements the leader node responsibilities within the BZZZ cluster, // This package implements the leader node responsibilities within the CHORUS cluster,
// where only the elected leader performs context generation, coordinates distributed // where only the elected leader performs context generation, coordinates distributed
// operations, and manages cluster-wide contextual intelligence tasks. It integrates // operations, and manages cluster-wide contextual intelligence tasks. It integrates
// with the BZZZ election system to ensure consistent leadership and proper failover. // with the CHORUS election system to ensure consistent leadership and proper failover.
// //
// Key Features: // Key Features:
// - Leader-only context generation to prevent conflicts and ensure consistency // - Leader-only context generation to prevent conflicts and ensure consistency
@@ -66,7 +66,7 @@
// } // }
// //
// Leader Election Integration: // Leader Election Integration:
// The context manager automatically integrates with the BZZZ election system, // The context manager automatically integrates with the CHORUS election system,
// responding to leadership changes, handling graceful transitions, and ensuring // responding to leadership changes, handling graceful transitions, and ensuring
// no context generation operations are lost during failover events. State // no context generation operations are lost during failover events. State
// transfer includes queued requests, active jobs, and coordination metadata. // transfer includes queued requests, active jobs, and coordination metadata.
@@ -105,7 +105,7 @@
// - Conflict detection and resolution for concurrent changes // - Conflict detection and resolution for concurrent changes
// //
// Security Integration: // Security Integration:
// All leader operations integrate with the BZZZ security model: // All leader operations integrate with the CHORUS security model:
// - Role-based authorization for context generation requests // - Role-based authorization for context generation requests
// - Encrypted communication between leader and cluster nodes // - Encrypted communication between leader and cluster nodes
// - Audit logging of all leadership decisions and actions // - Audit logging of all leadership decisions and actions

12
pkg/slurp/leader/election_integration.go
View File

@@ -7,14 +7,14 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/election" "chorus/pkg/election"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/slurp/intelligence" "chorus/pkg/slurp/intelligence"
"chorus.services/bzzz/pkg/slurp/storage" "chorus/pkg/slurp/storage"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// ElectionIntegratedContextManager integrates SLURP context management with BZZZ election system // ElectionIntegratedContextManager integrates SLURP context management with CHORUS election system
type ElectionIntegratedContextManager struct { type ElectionIntegratedContextManager struct {
*LeaderContextManager // Embed the base context manager *LeaderContextManager // Embed the base context manager

12
pkg/slurp/leader/enhanced_manager.go
View File

@@ -7,12 +7,12 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/election" "chorus/pkg/election"
"chorus.services/bzzz/pkg/health" "chorus/pkg/health"
"chorus.services/bzzz/pkg/metrics" "chorus/pkg/metrics"
"chorus.services/bzzz/pkg/slurp/intelligence" "chorus/pkg/slurp/intelligence"
"chorus.services/bzzz/pkg/slurp/storage" "chorus/pkg/slurp/storage"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// EnhancedLeaderManager provides enhanced leadership lifecycle management for SLURP // EnhancedLeaderManager provides enhanced leadership lifecycle management for SLURP

16
pkg/slurp/leader/integration_example.go
View File

@@ -6,13 +6,13 @@ import (
"log" "log"
"time" "time"
"chorus.services/bzzz/pkg/config" "chorus/pkg/config"
"chorus.services/bzzz/pkg/election" "chorus/pkg/election"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/slurp/intelligence" "chorus/pkg/slurp/intelligence"
"chorus.services/bzzz/pkg/slurp/storage" "chorus/pkg/slurp/storage"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
"chorus.services/bzzz/pubsub" "chorus/pubsub"
libp2p "github.com/libp2p/go-libp2p/core/host" libp2p "github.com/libp2p/go-libp2p/core/host"
) )
@@ -282,7 +282,7 @@ func (sys *SLURPLeaderSystem) initializeContextComponents(ctx context.Context) e
func (sys *SLURPLeaderSystem) initializeElectionSystem(ctx context.Context) error { func (sys *SLURPLeaderSystem) initializeElectionSystem(ctx context.Context) error {
sys.logger.Debug("Initializing election system") sys.logger.Debug("Initializing election system")
// Convert to base BZZZ config // Convert to base CHORUS config
bzzzConfig := sys.config.ToBaseBZZZConfig() bzzzConfig := sys.config.ToBaseBZZZConfig()
// Create SLURP election configuration // Create SLURP election configuration

12
pkg/slurp/leader/manager.go
View File

@@ -8,12 +8,12 @@ import (
"sync" "sync"
"time" "time"
"chorus.services/bzzz/pkg/election" "chorus/pkg/election"
"chorus.services/bzzz/pkg/dht" "chorus/pkg/dht"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
"chorus.services/bzzz/pkg/slurp/intelligence" "chorus/pkg/slurp/intelligence"
"chorus.services/bzzz/pkg/slurp/storage" "chorus/pkg/slurp/storage"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// ContextManager handles leader-only context generation duties // ContextManager handles leader-only context generation duties

4
pkg/slurp/leader/types.go
View File

@@ -3,8 +3,8 @@ package leader
import ( import (
"time" "time"
"chorus.services/bzzz/pkg/ucxl" "chorus/pkg/ucxl"
slurpContext "chorus.services/bzzz/pkg/slurp/context" slurpContext "chorus/pkg/slurp/context"
) )
// Priority represents priority levels for context generation requests // Priority represents priority levels for context generation requests

6
pkg/slurp/roles/doc.go
View File

@@ -3,12 +3,12 @@
// This package implements comprehensive role-based access control (RBAC) for contextual // This package implements comprehensive role-based access control (RBAC) for contextual
// intelligence, ensuring that context information is appropriately filtered, encrypted, // intelligence, ensuring that context information is appropriately filtered, encrypted,
// and distributed based on role permissions and security requirements. It integrates // and distributed based on role permissions and security requirements. It integrates
// with the existing BZZZ crypto system to provide secure, scalable access control. // with the existing CHORUS crypto system to provide secure, scalable access control.
// //
// Key Features: // Key Features:
// - Hierarchical role definition and management // - Hierarchical role definition and management
// - Context filtering based on role permissions and access levels // - Context filtering based on role permissions and access levels
// - Integration with BZZZ crypto system for role-based encryption // - Integration with CHORUS crypto system for role-based encryption
// - Dynamic permission evaluation and caching for performance // - Dynamic permission evaluation and caching for performance
// - Role-specific context views and perspectives // - Role-specific context views and perspectives
// - Audit logging for access control decisions // - Audit logging for access control decisions
@@ -88,7 +88,7 @@
// //
// Security Model: // Security Model:
// All access control decisions are based on cryptographically verified // All access control decisions are based on cryptographically verified
// role assignments and permissions. The system integrates with the BZZZ // role assignments and permissions. The system integrates with the CHORUS
// crypto infrastructure to ensure secure key distribution and context // crypto infrastructure to ensure secure key distribution and context
// encryption, preventing unauthorized access even in case of node // encryption, preventing unauthorized access even in case of node
// compromise or network interception. // compromise or network interception.

Some files were not shown because too many files have changed in this diff Show More