KNIRV-NEXUS: Decentralized Validation Environment
KNIRV-NEXUS is a unified implementation of the Decentralized Validation Environment (DVE) for the KNIRV Network. It provides a secure, scalable platform for validating SkillNodes and Base LLMs using a modern architecture that combines Next.js frontend with Go backend services in a single deployable binary.
๐๏ธ Architecture Overview
KNIRV-NEXUS implements a unified architecture with embedded frontend and backend services:
Unified Binary Architecture
- Main Wrapper (main.go
): Embeds both frontend and backend into a single executable
- Frontend Embedding: Next.js build output embedded via //go:embed all:out
- Backend Embedding: Unified backend binary embedded via //go:embed bin/nexus-backend
- API Proxy: Gin-based proxy routing /api/*
requests to embedded backend
- Static Serving: Embedded filesystem serving Next.js static assets
Core Backend Services
- DVE Manager: Orchestrates DVE nodes, manages task allocation, and monitors system health - Validation Core: Executes validation tasks with TEE support and cryptographic proofs - Agent Server: Manages WASM plugin agents and runtime execution - Data Engine: BuntDB-based data processing, metrics aggregation, and alerting - CDE Service: Cloud Development Environments for isolated execution - DNS Service: Dynamic DNS management for distributed nodes - P2P Manager: libp2p-based networking for node discovery and communication
> Note: KNIRV-NEXUS integrates with KNIRVGATEWAY for production routing. The unified architecture enables both standalone deployment and gateway integration.
Frontend Technology Stack
- Framework: Next.js 15 with App Router - UI Components: shadcn/ui built on Radix UI primitives - Styling: Tailwind CSS 4 with custom KNIRV theme - Real-time: Socket.io for live updates and notifications - State Management: React hooks and context - Type Safety: TypeScript with strict configuration - Authentication: Role-based access control with JWT - Embedding: Static build output embedded in Go binary
Backend Infrastructure
- Language: Go 1.21+ with modern concurrency patterns - Database: BuntDB (embedded key-value store with custom indexes) - Networking: libp2p for P2P communication and node discovery - Configuration: Viper for hierarchical configuration management - Web Framework: Gorilla Mux for HTTP routing and middleware - Real-time: WebSocket support for live data streaming - Container Runtime: Podman (rootless containers) for production - Orchestration: Kubernetes with production-ready configurations
๐งช Phase 7 Testing Infrastructure
Testing Architecture
KNIRVNEXUS implements comprehensive testing across multiple layers:Backend Testing (Go)
`bash
Run backend unit tests
cd backend && go test -v ./tests/...Run specific test suites
go test -v ./tests/phase6_comprehensive_unit_test.go go test -v ./tests/integration_test.go go test -v ./tests/architecture_test.go
`Frontend Testing (Next.js)
`bash
Run frontend tests
npm testType checking
npm run type-checkLinting
npm run lint
`Integration with Network Tests
`bash
From project root - run KNIRVNEXUS network integration tests
cd integration-tests && go test -v -run TestKNIRVNEXUSRun comprehensive KNIRVNEXUS test suite
make test-nexusRun specific test categories
make test-nexus-unit # Unit tests only make test-nexus-integration # Integration tests only make test-nexus-e2e # End-to-end tests only make test-nexus-performance # Performance tests only make test-nexus-security # Security tests only
`๐ ๏ธ Build System
KNIRV-NEXUS uses a unified build process that creates a single deployable binary containing both frontend and backend:
Build Process Overview
1. Frontend Build: Next.js builds static output to out/
directory
2. Backend Build: Go builds unified backend binary to bin/nexus-backend
3. Embedding: Main wrapper embeds both frontend and backend using go:embed
4. Final Binary: Single executable containing complete application
Core Build Commands
`bash
Quick Development Setup
npm install # Install frontend dependencies npm run build # Build Next.js frontend cd backend && go build -o ../bin/nexus-backend ./main.go # Build backend go build -o knirv-nexus main.go # Build unified binaryDevelopment Mode
npm run dev # Start Next.js dev server (port 3000) cd backend && go run main.go --config config/development.yaml # Backend onlyProduction Build
npm run build # Build optimized frontend cd backend && CGO_ENABLED=1 go build -ldflags="-s -w" -o ../bin/nexus-backend ./main.go go build -ldflags="-s -w -X main.Version=v1.0.0" -o knirv-nexus main.goTesting
npm test # Frontend tests cd backend && go test ./... # Backend tests
`Deployment Options
`bash
Standalone Binary
./knirv-nexus # Runs on port 8090 (configurable)With Custom Configuration
./knirv-nexus --config config/production.yamlEnvironment Variables
NEXUS_PORT=8080 NEXUS_BACKEND_PORT=8081 ./knirv-nexusDocker Deployment
docker build -t knirv/nexus:latest . docker run -p 8090:8090 knirv/nexus:latest
`๐ Current Implementation Status
โ Fully Implemented Features
Unified Architecture
- Single Binary Deployment: Frontend and backend embedded in one executable - Embedded Frontend: Next.js build output served via Go's embed filesystem - API Proxy: Gin-based routing of/api/*
requests to embedded backend
- Configuration Management: Viper-based hierarchical configuration with YAML supportFrontend (Next.js with shadcn/ui)
- Modern UI Framework: Next.js 15 with App Router and TypeScript - Component Library: Complete shadcn/ui component set built on Radix UI - Dashboard Interface: Comprehensive dashboard with tabs for all major functions - Responsive Design: Mobile-first design with Tailwind CSS and KNIRV theme - Authentication UI: Role-based components and user profile managementBackend Services
- DVE Manager: Node orchestration and task allocation service - Validation Core: Task queue and validation execution framework - Agent Server: WASM plugin agent management and runtime execution - Data Engine: BuntDB-based metrics, alerts, and event processing - CDE Service: Cloud Development Environment management - DNS Service: Dynamic DNS management for distributed nodesDatabase & Storage
- BuntDB Integration: Embedded key-value store with custom indexes - Data Engine: Comprehensive metrics aggregation and alerting system - Event Processing: Real-time event ingestion and processing pipeline - Report Generation: User and system report storage and retrievalโ ๏ธ Partially Implemented Features
P2P Networking (30% Complete)
- Basic Structure: libp2p manager framework in place - Missing: DHT integration, GossipSub messaging, active node discovery - Status: Foundation exists but not operationalValidation Engine (40% Complete)
- Task Management: Queue system and basic task structures - Missing: Actual validation logic, cryptographic proof generation - Status: Framework ready but core functionality incompleteAPI Endpoints (50% Complete)
- Route Structure: All service routes defined with proper handlers - Missing: Complete CRUD operations, many endpoints return placeholder data - Status: Infrastructure ready but implementations incompleteโ Missing Critical Features
TEE (Trusted Execution Environment)
- Status: Only basic type definitions exist - Missing: SGX/SEV-SNP/TDX integration, attestation, secure execution - Impact: Core security guarantees not implementedJWT Authentication System
- Status: Frontend auth components exist but no backend implementation - Missing: JWT middleware, user management, role-based access control - Impact: Security model incompleteReal-time Updates
- Status: Frontend expects Socket.io, backend has basic WebSocket stubs - Missing: Functional Socket.io server, SSE implementation - Impact: Dashboard real-time features non-functionalOperational Modes (GUI/Headless)
- Status: Documented but not implemented - Missing: Mode switching logic, GUI-specific configurations - Impact: Deployment flexibility limited> Note: See Nexus_Gap_Analysis.md
for detailed analysis of implementation gaps and recommended actions.
๐ Quick Start
Prerequisites
- Go 1.21+: Required for backend compilation - Node.js 18+: Required for frontend development and building - npm: Package manager for frontend dependencies - Git: Version control for cloning repository
Quick Development Setup
Get started in 5 minutes:
`bash
1. Clone repository
git clone https://github.com/knirv/KNIRV_NETWORK.git cd KNIRV_NETWORK/KNIRVNEXUS2. Install frontend dependencies
npm install3. Build frontend
npm run build4. Build backend
cd backend go mod tidy go build -o ../bin/nexus-backend ./main.go cd ..5. Build unified binary
go build -o knirv-nexus main.go6. Run application
./knirv-nexus7. Access application at http://localhost:8090
`For development with hot reload:
`bash
Terminal 1: Frontend development server
npm run dev # Runs on http://localhost:3000Terminal 2: Backend development server
cd backend go run main.go --config config/development.yaml # Runs on http://localhost:8080
`Deployment
1. Clone the repository:
`bash
git clone https://github.com/knirv/KNIRV_NETWORK.git
cd KNIRV_NETWORK/KNIRVNEXUS
`
2. Build the components:
`bash
chmod +x scripts/build.sh
./scripts/build.sh
`
3. Deploy to Kubernetes:
`bash
chmod +x scripts/deploy.sh
./scripts/deploy.sh
`
4. Verify deployment:
`bash
kubectl get pods -n knirv-nexus
`
Development Setup
Frontend Development
1. Install frontend dependencies:
`bash
npm install
`2. Start development server:
`bash
npm run dev
`
3. Build frontend:
`bash
npm run build
`
4. Start custom server with Socket.io:
`bash
npm run start
`
Backend Development
##### Prerequisites - Go 1.21+ installed - Git for version control - Optional: Docker for containerized builds
##### Environment Setup
1. Set up environment variables:
`bash
# For development (GUI mode, no auth required)
cp .env.development .env
# OR for production (headless mode, auth required)
cp .env.production .env
# Then set JWT_SECRET environment variable:
export JWT_SECRET="your-secure-jwt-secret-here"
`
2. Install backend dependencies:
`bash
cd backend
go mod tidy
`
3. Create required directories:
`bash
mkdir -p data logs reports keys
`
##### Building the Backend
1. Quick development build:
`bash
cd backend
# Build DVE Manager go build -o bin/dve-manager ./cmd/dve-manager/
# Build Validation Core go build -o bin/validation-core ./cmd/validation-core/
# Build API Gateway (if available)
go build -o bin/api-gateway ./cmd/api-gateway/
`
2. Production build (static linking):
`bash
cd backend
# Build with static linking for containers CGO_ENABLED=1 GOOS=linux go build -a -installsuffix cgo \ -ldflags '-extldflags "-static" -s -w' \ -o bin/dve-manager ./cmd/dve-manager/
CGO_ENABLED=1 GOOS=linux go build -a -installsuffix cgo \
-ldflags '-extldflags "-static" -s -w' \
-o bin/validation-core ./cmd/validation-core/
`
3. Using the build script:
`bash
# Full build with Docker images
./scripts/build.sh
# Build binaries only (skip Docker) ./scripts/build.sh --skip-docker
# Skip tests and security checks
./scripts/build.sh --skip-tests --skip-security
`
##### Running the Services
1. Development mode (with GUI):
`bash
cd backend
# Load development environment export $(cat ../.env.development | xargs)
# Run DVE Manager with GUI ./bin/dve-manager --gui
# In another terminal, run Validation Core with GUI
./bin/validation-core --gui
`
2. Production mode (headless):
`bash
cd backend
# Load production environment export $(cat ../.env.production | xargs) export JWT_SECRET="your-secure-jwt-secret"
# Run services
./bin/dve-manager
./bin/validation-core
`
3. With custom configuration:
`bash
./bin/dve-manager --config ./config/custom.yaml --port 8080
./bin/validation-core --config ./config/custom.yaml --port 8081
`
##### Testing
1. Run unit tests:
`bash
cd backend
go test ./tests/... -v
`
2. Run integration tests:
`bash
cd backend
go test ./tests/integration_test.go -v
`
3. Run with coverage:
`bash
cd backend
go test ./tests/... -v -coverprofile=coverage.out
go tool cover -html=coverage.out -o coverage.html
`
Full Stack Development
1. Build frontend first:
`bash
npm run build
`2. Start backend with GUI mode:
`bash
cd backend
./dve-manager -gui
./validation-core -gui
`
3. Access the application: - Frontend: http://localhost:3000 (development) - GUI Mode: http://localhost:9080 (DVE Manager), http://localhost:9081 (Validation Core) - API: http://localhost:8080 (DVE Manager), http://localhost:8081 (Validation Core)
๐ Project Structure
`
KNIRVNEXUS/
โโโ src/ # Next.js Frontend
โ โโโ app/ # Next.js App Router
โ โ โโโ layout.tsx # Root layout
โ โ โโโ page.tsx # Home page
โ โ โโโ globals.css # Global styles
โ โ โโโ api/ # API routes
โ โโโ components/ # React components
โ โ โโโ ui/ # shadcn/ui components
โ โโโ hooks/ # Custom React hooks
โ โ โโโ use-knirv-socket.ts # Socket.io integration
โ โ โโโ use-mobile.ts # Mobile detection
โ โ โโโ use-toast.ts # Toast notifications
โ โโโ lib/ # Utility libraries
โ โโโ db.ts # Database utilities
โ โโโ socket.ts # Socket.io client
โ โโโ utils.ts # General utilities
โโโ backend/ # Go backend services
โ โโโ cmd/ # Service entry points
โ โ โโโ dve-manager/ # DVE Manager service
โ โ โโโ validation-core/ # Validation Core service
โ โโโ internal/ # Internal packages
โ โ โโโ config/ # Configuration management
โ โ โโโ database/ # BuntDB wrapper
โ โ โโโ models/ # Data models
โ โ โโโ services/ # Business logic services
โ โโโ pkg/ # Public packages
โ โ โโโ p2p/ # P2P networking
โ โ โโโ sse/ # Server-Sent Events
โ โโโ tests/ # Test suites
โ โโโ Dockerfile.* # Container definitions
โโโ k8s/ # Kubernetes manifests
โ โโโ namespace.yaml # Namespace and quotas
โ โโโ configmap.yaml # Configuration
โ โโโ secrets.yaml # Secrets management
โ โโโ *-deployment.yaml # Service deployments
โโโ scripts/ # Automation scripts
โ โโโ build.sh # Build automation
โ โโโ deploy.sh # Deployment automation
โโโ public/ # Static assets
โ โโโ logo.svg # KNIRV logo
โ โโโ robots.txt # SEO configuration
โโโ prisma/ # Database schema
โ โโโ schema.prisma # Prisma schema definition
โโโ config/ # Configuration files
โ โโโ knirv-nexus.yaml # Main configuration
โ โโโ development.yaml # Development config
โ โโโ production.yaml # Production config
โโโ package.json # Frontend dependencies
โโโ next.config.ts # Next.js configuration
โโโ tailwind.config.ts # Tailwind CSS configuration
โโโ components.json # shadcn/ui configuration
โโโ server.ts # Custom server with Socket.io
โโโ tsconfig.json # TypeScript configuration
โโโ README.md # This file
`
๐ง API Documentation
> Note: KNIRV-NEXUS APIs are accessed through the primary KNIRVGATEWAY at /api/nexus/*
endpoints. Direct service access is available for development and internal communication.
Direct Service APIs
KNIRV-NEXUS exposes two main services with direct API access:
DVE Manager Service (Port 8080)
`bash
Health check
curl -X GET http://dve-manager:8080/healthRegister a new DVE node
curl -X POST http://dve-manager:8080/api/v1/nodes \ -H "Content-Type: application/json" \ -d '{ "name": "validator-1", "tee_type": "sgx", "stake_amount": 1000000, "location": "us-east-1", "ip_address": "192.168.1.100", "public_key": "...", "capabilities": ["skillnode", "base_llm"] }'List DVE nodes
curl -X GET http://dve-manager:8080/api/v1/nodesSystem health
curl -X GET http://dve-manager:8080/api/v1/system/health
`Validation Core Service (Port 8081)
`bash
Health check
curl -X GET http://validation-core:8081/healthCreate validation task
curl -X POST http://validation-core:8081/api/v1/tasks \ -H "Content-Type: application/json" \ -d '{ "type": "skillnode", "priority": 5, "skill_code": "def hello(): return \"Hello, World!\"", "test_cases": [...], "required_tee_type": "sgx" }'List validation tasks
curl -X GET http://validation-core:8081/api/v1/tasksGet validation results
curl -X GET http://validation-core:8081/api/v1/results
`Gateway Integration
For production use, access KNIRV-NEXUS through KNIRVGATEWAY:
`bash
Via KNIRVGATEWAY (Production)
curl -X GET https://gateway.knirv.network/api/nexus/nodes curl -X POST https://gateway.knirv.network/api/nexus/tasksReal-time updates via SSE
const eventSource = new EventSource('https://gateway.knirv.network/api/nexus/sse'); eventSource.addEventListener('nexus-nodes', function(event) { const data = JSON.parse(event.data); console.log('Node update:', data); });
`๐ง Operational Modes
KNIRV-NEXUS supports two operational modes for different deployment scenarios:
Headless Mode (Default - Production)
Use Case: Production deployments, Kubernetes clusters, cloud environments
`bash
Default headless mode
./dve-manager ./validation-coreWith configuration file
./dve-manager --config ./config/production.yaml
`Characteristics: - API-only access (no web interface) - Full JWT authentication required - Binds to all network interfaces (0.0.0.0) - Production-optimized resource usage - Comprehensive audit logging - Kubernetes-ready with health checks
GUI Mode (Local Administration)
Use Case: Local development, system administration, debugging
`bash
Enable GUI mode
./dve-manager -gui ./validation-core -guiWith custom configuration
./dve-manager -gui --config ./config/development.yaml
`Characteristics: - Built-in web interface using existing Next.js frontend - No authentication required (admin environment assumed) - Localhost-only access (127.0.0.1) - Real-time updates via WebSocket - Extended debugging and diagnostic tools - Direct access to configuration management
GUI Access: - DVE Manager GUI: http://localhost:9080 - Validation Core GUI: http://localhost:9081 - API Access: http://localhost:8080, http://localhost:8081
Mode Comparison
| Feature | Headless Mode | GUI Mode | |---------|---------------|----------| | Target Use | Production | Local admin | | Authentication | JWT required | None | | Web Interface | None | Built-in Next.js frontend | | Network Access | All interfaces | Localhost only | | Resource Usage | Minimal | Higher (includes web server) | | Security | Full RBAC + audit | Local access only |
โ๏ธ Configuration
Configuration Management (Viper)
KNIRV-NEXUS uses Viper for professional configuration management with the following hierarchy (highest to lowest precedence):
1. CLI Flags: --gui
, --port
, --config
2. Environment Variables: KNIRV_GUI_ENABLED
, KNIRV_SERVICE_PORT
3. Configuration File: config/knirv-nexus.yaml
4. Default Values: Hardcoded sensible defaults
Configuration File Structure
`yaml
config/knirv-nexus.yaml
mode: headless # headless | guiservice: port: 8080 bind_address: "0.0.0.0" name: "dve-manager"
gui: enabled: false port: 9080 frontend_path: "./dist"
security: auth_required: true tls_enabled: true audit_logging: true jwt_secret: "${KNIRV_JWT_SECRET}"
roles: validator: permissions: ["node:read", "node:update", "tasks:read", "results:read"] scoped_access: true admin: permissions: [":"] scoped_access: false observer: permissions: ["*:read"] scoped_access: false
database: type: "buntdb" path: "./data/nexus.db"
network:
chain_id: "knirv-nexus-mainnet"
p2p_port: 4001
`
Environment Variables
| Variable | Description | Default |
|----------|-------------|---------|
| KNIRV_MODE
| Operational mode | headless
|
| KNIRV_GUI_ENABLED
| Enable GUI mode | false
|
| KNIRV_SERVICE_PORT
| API server port | 8080
|
| KNIRV_GUI_PORT
| GUI server port | 9080
|
| KNIRV_CHAIN_ID
| Blockchain network ID | knirv-nexus-mainnet
|
| KNIRV_DATABASE_PATH
| Database file path | ./data/nexus.db
|
| KNIRV_P2P_PORT
| P2P networking port | 4001
|
| KNIRV_LOG_LEVEL
| Logging level | info
|
| KNIRV_JWT_SECRET
| JWT signing secret | Required |
Kubernetes Configuration
Key configuration files:
- k8s/namespace.yaml
: Namespace and resource quotas
- k8s/configmap.yaml
: Application configuration
- k8s/secrets.yaml
: Sensitive configuration (JWT secrets, TLS certs)
- k8s/*-deployment.yaml
: Service deployments
๐ Security
TEE Support
KNIRV-NEXUS supports multiple TEE technologies:
- Intel SGX: Hardware-based secure enclaves - AMD SEV-SNP: Secure encrypted virtualization - Intel TDX: Trust domain extensions - Software TEE: Simulation for development/testing
Network Security
- P2P Encryption: All P2P communications are encrypted - TLS Termination: HTTPS/TLS for all API endpoints - JWT Authentication: Secure token-based authentication - RBAC: Role-based access control
Container Security
- Rootless Containers: Podman-based rootless execution - Minimal Base Images: Hardened Kali Linux base - Security Scanning: Automated vulnerability scanning - Network Policies: Kubernetes network isolation
๐ Monitoring and Observability
Metrics
KNIRV-NEXUS exposes Prometheus metrics on /metrics
endpoints:
- System health and performance metrics - DVE node status and resource utilization - Validation task throughput and success rates - P2P network topology and latency
Logging
Structured JSON logging with configurable levels:
`bash
View logs
kubectl logs -f deployment/api-gateway -n knirv-nexus kubectl logs -f deployment/dve-manager -n knirv-nexus kubectl logs -f deployment/validation-core -n knirv-nexus
`Health Checks
All services provide health check endpoints:
- GET /health
: Basic health status
- Kubernetes liveness and readiness probes
- Automatic service recovery and scaling
๐งช Testing
The implementation includes comprehensive testing:
- Unit Tests: Individual component testing - Integration Tests: End-to-end service testing - Performance Tests: Validation throughput benchmarks - Security Tests: Vulnerability scanning
Run tests with:
`bash
cd backend
go test ./tests/... -v
`
๐ ๏ธ Troubleshooting
Common Backend Issues
1. JWT Secret Configuration Error
Error:Failed to load configuration: invalid configuration: security.jwt_secret is required in headless mode with authentication
Causes & Solutions:
- Environment variable not set:
`bash
# Set JWT_SECRET environment variable
export JWT_SECRET="your-secure-jwt-secret-here"
# Or use development environment
cp .env.development .env
export $(cat .env | xargs)
`
- Using GUI mode but auth still required:
`bash
# Use development environment for GUI mode
export KNIRV_MODE=gui
export KNIRV_AUTH_REQUIRED=false
# Or run with GUI flag
./bin/dve-manager --gui
`
- Shell variable expansion issue in .env file:
`bash
# Instead of KNIRV_JWT_SECRET=${JWT_SECRET}
# Use direct value: KNIRV_JWT_SECRET=your-actual-secret
`
2. Build Failures
Error:go build
fails with dependency issuesSolutions:
`bash
cd backend
Clean module cache
go clean -modcacheUpdate dependencies
go mod tidyVerify dependencies
go mod verifyBuild with verbose output
go build -v ./cmd/dve-manager/
`3. Database Connection Issues
Error: Database path not accessibleSolutions:
`bash
Create data directory
mkdir -p dataCheck permissions
chmod 755 dataUse absolute path in config
export KNIRV_DATABASE_PATH="$(pwd)/data/nexus.db"
`4. Port Already in Use
Error:bind: address already in use
Solutions:
`bash
Check what's using the port
lsof -i :8080Kill process using port
kill -9 $(lsof -t -i:8080)Use different port
./bin/dve-manager --port 8081
`5. P2P Network Issues
Error: P2P connection failuresSolutions:
`bash
Check firewall
sudo ufw statusAllow P2P port
sudo ufw allow 4001Check if port is accessible
nc -zv localhost 4001
`Configuration Troubleshooting
Environment Variable Priority
Configuration is loaded in this order (highest to lowest priority): 1. CLI flags:--gui
, --port
, --config
2. Environment variables: KNIRV_*
3. Configuration file: config/knirv-nexus.yaml
4. Default valuesDebug Configuration Loading
`bash
Enable debug logging
export KNIRV_LOG_LEVEL=debugRun with verbose output
./bin/dve-manager --gui 2>&1 | grep -i config
`Validate Configuration
`bash
Test configuration without starting service
./bin/dve-manager --config ./config/development.yaml --help
`Development Environment Issues
1. Go Version Compatibility
Error: Build fails with Go version issuesSolutions:
`bash
Check Go version
go versionShould be 1.21+
Update Go if needed
sudo rm -rf /usr/local/go wget https://golang.org/dl/go1.21.0.linux-amd64.tar.gz sudo tar -C /usr/local -xzf go1.21.0.linux-amd64.tar.gz
`2. CGO Dependencies
Error: CGO compilation failsSolutions:
`bash
Install build essentials
sudo apt-get update sudo apt-get install build-essentialFor static builds
sudo apt-get install musl-dev
`Kubernetes Deployment Issues
1. Pod startup failures: Check resource limits and node capacity 2. P2P connectivity issues: Verify firewall rules and port accessibility 3. Database errors: Check persistent volume availability 4. Authentication failures: Verify JWT secret configuration in secrets
Debug Commands
`bash
Check pod status
kubectl get pods -n knirv-nexus -o wideView pod logs
kubectl logs -f pod/Execute into pod
kubectl exec -it pod/Check service endpoints
kubectl get endpoints -n knirv-nexusView events
kubectl get events -n knirv-nexus --sort-by='.lastTimestamp'
`๐ค Contributing
1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests for new functionality
5. Run the test suite: go test ./tests/... -v
6. Submit a pull request
๐ License
This project is part of the KNIRV Network and follows the project's licensing terms.
๐ Support
For support and questions:
- Create an issue in the GitHub repository - Join the KNIRV Network community discussions - Review the technical documentation in the codebase
Built with โค๏ธ for the developer community. Supercharged by Z.ai ๐