--- name: when-using-flow-nexus-platform-use-flow-nexus-platform description: Comprehensive Flow Nexus platform management covering authentication, sandboxes, storage, databases, app deployment, payments, and monitoring. This SOP provides end-to-end platform operations. --- # Flow Nexus Platform Management SOP ```yaml metadata: skill_name: when-using-flow-nexus-platform-use-flow-nexus-platform version: 1.0.0 category: platform-integration difficulty: intermediate estimated_duration: 30-60 minutes trigger_patterns: - "flow nexus platform" - "manage flow nexus" - "flow nexus authentication" - "deploy to flow nexus" - "flow nexus sandboxes" dependencies: - flow-nexus MCP server - Valid email for registration - Claude Flow hooks agents: - cicd-engineer (infrastructure orchestrator) - backend-dev (service integrator) - system-architect (platform designer) success_criteria: - Authentication successful - Services configured and running - Application deployed - Monitoring active - Payment system operational ``` ## Overview Comprehensive Flow Nexus platform management covering authentication, sandboxes, storage, databases, app deployment, payments, and monitoring. This SOP provides end-to-end platform operations. ## Prerequisites **Required:** - Flow Nexus MCP server installed - Valid email address - Internet connectivity **Optional:** - E2B API key for enhanced features - Anthropic API key for Claude Code sandboxes - Payment method for credits **Verification:** ```bash # Check Flow Nexus MCP availability claude mcp list | grep flow-nexus # Test connection npx flow-nexus@latest --version ``` ## Agent Responsibilities ### cicd-engineer (Infrastructure Orchestrator) **Role:** Manage infrastructure, sandboxes, deployments, and CI\/CD pipelines **Expertise:** - Cloud infrastructure management - Container orchestration - Deployment automation - Resource optimization **Output:** Infrastructure configuration, deployment pipelines, monitoring setup ### backend-dev (Service Integrator) **Role:** Integrate platform services, APIs, and business logic **Expertise:** - API integration - Service architecture - Database design - Authentication flows **Output:** Service integration code, API endpoints, database schemas ### system-architect (Platform Designer) **Role:** Design platform architecture, scalability patterns, and system integration **Expertise:** - System architecture - Scalability patterns - Performance optimization - Security design **Output:** Architecture diagrams, technical specifications, integration patterns ## Phase 1: Authentication Setup **Objective:** Register user, authenticate, verify access to platform services **Evidence-Based Validation:** - User registered successfully - Authentication token obtained - Session active and verified - User profile accessible **cicd-engineer Actions:** ```bash # Pre-task coordination npx claude-flow@alpha hooks pre-task --description "Setup Flow Nexus authentication" # Restore session npx claude-flow@alpha hooks session-restore --session-id "flow-nexus-setup-$(date +%s)" # Check current authentication status mcp__flow-nexus__auth_status { "detailed": true } # If not authenticated, register new user mcp__flow-nexus__user_register { "email": "user@example.com", "password": "SecurePassword123!", "username": "platform_user", "full_name": "Platform User" } # Login to create session mcp__flow-nexus__user_login { "email": "user@example.com", "password": "SecurePassword123!" } # Store user ID in memory USER_ID="[returned_user_id]" npx claude-flow@alpha memory store --key "flow-nexus\/user-id" --value "$USER_ID" # Get user profile mcp__flow-nexus__user_profile { "user_id": "$USER_ID" } # Store profile in memory npx claude-flow@alpha memory store \ --key "flow-nexus\/user-profile" \ --value "{\"user_id\": \"$USER_ID\", \"tier\": \"free\", \"timestamp\": \"$(date -Iseconds)\"}" ``` **backend-dev Actions:** ```bash # Create platform configuration mkdir -p platform\/{config,services,scripts,docs} cat > platform\/config\/flow-nexus.json << 'EOF' { "platform": "flow-nexus", "version": "1.0.0", "authentication": { "type": "email_password", "session_timeout": 3600 }, "services": { "sandboxes": { "enabled": true, "max_concurrent": 5 }, "storage": { "enabled": true, "max_size_mb": 1000 }, "databases": { "enabled": true, "max_connections": 10 }, "workflows": { "enabled": true, "max_agents": 8 } }, "limits": { "requests_per_minute": 60, "storage_mb": 1000, "compute_hours": 10 } } EOF # Post-edit hook npx claude-flow@alpha hooks post-edit --file "platform\/config\/flow-nexus.json" --memory-key "flow-nexus\/config" ``` **system-architect Actions:** ```bash # Document authentication flow cat > platform\/docs\/AUTHENTICATION.md << 'EOF' # Flow Nexus Authentication ## Overview Flow Nexus uses email\/password authentication with JWT tokens for session management. ## Authentication Flow 1. **Registration**: Create new user account - Email validation required - Password complexity enforced - Username unique constraint 2. **Login**: Obtain authentication token - Returns JWT token - Token expires after 1 hour - Refresh token available 3. **Session Management**: Maintain active session - Auto-refresh before expiry - Logout clears session - Multi-device support ## Security Best Practices - Use strong passwords (min 12 characters) - Enable 2FA when available - Rotate tokens regularly - Never commit credentials to git ## API Examples ### Register ```bash mcp__flow-nexus__user_register { "email": "user@example.com", "password": "secure_password" } ``` ### Login ```bash mcp__flow-nexus__user_login { "email": "user@example.com", "password": "secure_password" } ``` ### Logout ```bash mcp__flow-nexus__user_logout ``` EOF # Post-edit hook npx claude-flow@alpha hooks post-edit --file "platform\/docs\/AUTHENTICATION.md" --memory-key "flow-nexus\/auth-docs" ``` **Success Criteria:** - [ ] User registered successfully - [ ] Authentication token obtained - [ ] Configuration created - [ ] Documentation generated **Memory Persistence:** ```bash npx claude-flow@alpha memory store \ --key "flow-nexus\/phase1-complete" \ --value "{\"status\": \"complete\", \"user_id\": \"$USER_ID\", \"authenticated\": true, \"timestamp\": \"$(date -Iseconds)\"}" ``` ## Phase 2: Configure Services **Objective:** Setup sandboxes, storage, databases, and other platform services **Evidence-Based Validation:** - Sandboxes created and running - Storage buckets configured - Database connections established - Real-time subscriptions active **cicd-engineer Actions:** ```bash # Retrieve user ID USER_ID=$(npx claude-flow@alpha memory retrieve --key "flow-nexus\/user-id" | jq -r '.value') # Create sandbox for development mcp__flow-nexus__sandbox_create { "template": "node", "name": "dev-sandbox", "timeout": 3600, "env_vars": { "NODE_ENV": "development", "LOG_LEVEL": "debug" }, "install_packages": ["express", "axios", "dotenv"] } # Store sandbox ID SANDBOX_ID="[returned_sandbox_id]" npx claude-flow@alpha memory store --key "flow-nexus\/sandbox-id" --value "$SANDBOX_ID" # Configure sandbox with additional settings mcp__flow-nexus__sandbox_configure { "sandbox_id": "$SANDBOX_ID", "env_vars": { "API_URL": "https:\/\/api.flow-nexus.ruv.io", "MAX_RETRIES": "3" }, "install_packages": ["typescript", "jest"] } # Create storage bucket mcp__flow-nexus__storage_upload { "bucket": "platform-assets", "path": ".gitkeep", "content": "" } # Setup real-time subscriptions mcp__flow-nexus__realtime_subscribe { "table": "workflows", "event": "*" } # Store subscription ID SUBSCRIPTION_ID="[returned_subscription_id]" npx claude-flow@alpha memory store --key "flow-nexus\/subscription-id" --value "$SUBSCRIPTION_ID" # Notify completion npx claude-flow@alpha hooks notify --message "Services configured: sandbox, storage, real-time subscriptions" ``` **backend-dev Actions:** ```bash # Create service initialization script cat > platform\/scripts\/init-services.js << 'EOF' const { exec } = require('child_process'); const util = require('util'); const execPromise = util.promisify(exec); async function initializeSandbox() { console.log('Initializing sandbox...'); \/\/ Sandbox initialization logic return { status: 'success', sandbox_id: process.env.SANDBOX_ID }; } async function initializeStorage() { console.log('Initializing storage...'); \/\/ Storage setup logic return { status: 'success', bucket: 'platform-assets' }; } async function initializeDatabase() { console.log('Initializing database...'); \/\/ Database connection logic return { status: 'success', connected: true }; } async function main() { try { const sandbox = await initializeSandbox(); const storage = await initializeStorage(); const database = await initializeDatabase(); console.log('All services initialized successfully:', { sandbox, storage, database }); } catch (error) { console.error('Service initialization failed:', error); process.exit(1); } } main(); EOF # Post-edit hook npx claude-flow@alpha hooks post-edit --file "platform\/scripts\/init-services.js" --memory-key "flow-nexus\/init-script" # Create database schema cat > platform\/config\/schema.sql << 'EOF' -- Flow Nexus Platform Schema CREATE TABLE IF NOT EXISTS applications ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL, name VARCHAR(255) NOT NULL, description TEXT, status VARCHAR(50) DEFAULT 'active', created_at TIMESTAMP DEFAULT NOW(), updated_at TIMESTAMP DEFAULT NOW() ); CREATE TABLE IF NOT EXISTS deployments ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), application_id UUID REFERENCES applications(id), version VARCHAR(50) NOT NULL, sandbox_id VARCHAR(255), status VARCHAR(50) DEFAULT 'pending', created_at TIMESTAMP DEFAULT NOW() ); CREATE TABLE IF NOT EXISTS metrics ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), deployment_id UUID REFERENCES deployments(id), metric_type VARCHAR(100), metric_value JSONB, recorded_at TIMESTAMP DEFAULT NOW() ); CREATE INDEX idx_applications_user_id ON applications(user_id); CREATE INDEX idx_deployments_app_id ON deployments(application_id); CREATE INDEX idx_metrics_deployment_id ON metrics(deployment_id); EOF # Post-edit hook npx claude-flow@alpha hooks post-edit --file "platform\/config\/schema.sql" --memory-key "flow-nexus\/schema" ``` **system-architect Actions:** ```bash # Document service architecture cat > platform\/docs\/ARCHITECTURE.md << 'EOF' # Flow Nexus Platform Architecture ## System Components ### 1. Sandboxes (E2B) - Isolated code execution environments - Multiple templates (Node.js, Python, React) - Resource limits enforced - Environment variable support ### 2. Storage - Object storage for files - Bucket-based organization - Public URL generation - File upload\/download APIs ### 3. Databases - PostgreSQL with Supabase - Real-time subscriptions - Row-level security - Connection pooling ### 4. Workflows - Event-driven processing - Agent coordination - Task orchestration - Message queue integration ## Service Integration ``` ┌─────────────────────────────────────────┐ │ Flow Nexus Platform │ ├─────────────────────────────────────────┤ │ │ │ ┌──────────┐ ┌──────────┐ │ │ │ Sandboxes│ │ Storage │ │ │ │ (E2B) │ │(Supabase)│ │ │ └────┬─────┘ └────┬─────┘ │ │ │ │ │ │ ┌────▼─────────────▼─────┐ │ │ │ Event Bus │ │ │ │ (Real-time sync) │ │ │ └────┬────────────────────┘ │ │ │ │ │ ┌────▼─────┐ ┌──────────┐ │ │ │ Workflows│ │Databases │ │ │ │ (Claude │ │(Postgres)│ │ │ │ Flow) │ │ │ │ │ └──────────┘ └──────────┘ │ └─────────────────────────────────────────┘ ``` ## Scalability Patterns 1. **Horizontal Scaling**: Add more sandboxes 2. **Vertical Scaling**: Increase sandbox resources 3. **Load Balancing**: Distribute across regions 4. **Caching**: Redis for frequently accessed data 5. **CDN**: Static asset delivery ## Security Measures - Authentication required for all operations - API rate limiting enforced - Sandbox isolation with network controls - Encrypted data at rest and in transit - Audit logging for all actions EOF # Post-edit hook npx claude-flow@alpha hooks post-edit --file "platform\/docs\/ARCHITECTURE.md" --memory-key "flow-nexus\/architecture" ``` **Success Criteria:** - [ ] Sandbox created and configured - [ ] Storage bucket initialized - [ ] Database schema applied - [ ] Real-time subscriptions active **Memory Persistence:** ```bash npx claude-flow@alpha memory store \ --key "flow-nexus\/phase2-complete" \ --value "{\"status\": \"complete\", \"sandbox_id\": \"$SANDBOX_ID\", \"subscription_id\": \"$SUBSCRIPTION_ID\", \"timestamp\": \"$(date -Iseconds)\"}" ``` ## Phase 3: Deploy Applications **Objective:** Deploy applications using templates or custom configurations **Evidence-Based Validation:** - Application deployed successfully - Health checks passing - Metrics being collected - Public URL accessible **cicd-engineer Actions:** ```bash # List available templates mcp__flow-nexus__template_list { "category": "web", "limit": 10 } # Deploy from template mcp__flow-nexus__template_deploy { "template_name": "nextjs-starter", "deployment_name": "my-nextjs-app", "variables": { "anthropic_api_key": "$ANTHROPIC_API_KEY", "app_name": "My Next.js App", "port": "3000" }, "env_vars": { "NODE_ENV": "production", "DATABASE_URL": "$DATABASE_URL" } } # Store deployment ID DEPLOYMENT_ID="[returned_deployment_id]" npx claude-flow@alpha memory store --key "flow-nexus\/deployment-id" --value "$DEPLOYMENT_ID" # Subscribe to execution stream mcp__flow-nexus__execution_stream_subscribe { "deployment_id": "$DEPLOYMENT_ID", "stream_type": "claude-code" } # Monitor deployment status for i in {1..10}; do sleep 10 mcp__flow-nexus__execution_stream_status { "stream_id": "$DEPLOYMENT_ID" } done # Notify deployment completion npx claude-flow@alpha hooks notify --message "Application deployed successfully: $DEPLOYMENT_ID" ``` **backend-dev Actions:** ```bash # Create custom application deployment script cat > platform\/scripts\/deploy-app.sh << 'EOF' #!\/bin\/bash set -e APP_NAME="${1:-my-app}" SANDBOX_ID="${2:-$SANDBOX_ID}" echo "Deploying $APP_NAME to sandbox $SANDBOX_ID..." # Upload application files echo "Uploading files..." mcp__flow-nexus__sandbox_upload \ --sandbox_id="$SANDBOX_ID" \ --file_path="app.js" \ --content="$(cat platform\/services\/app.js)" # Execute startup script echo "Starting application..." mcp__flow-nexus__sandbox_execute \ --sandbox_id="$SANDBOX_ID" \ --code="npm start" \ --timeout=300 echo "Application deployed successfully!" echo "Access logs: mcp__flow-nexus__sandbox_logs --sandbox_id=$SANDBOX_ID" EOF chmod +x platform\/scripts\/deploy-app.sh # Create sample application cat > platform\/services\/app.js << 'EOF' const express = require('express'); const app = express(); const port = process.env.PORT || 3000; app.use(express.json()); app.get('\/health', (req, res) => { res.json({ status: 'healthy', timestamp: new Date().toISOString(), uptime: process.uptime() }); }); app.get('\/api\/info', (req, res) => { res.json({ name: 'Flow Nexus Platform App', version: '1.0.0', environment: process.env.NODE_ENV }); }); app.listen(port, () => { console.log(`Server running on port ${port}`); }); EOF # Post-edit hooks npx claude-flow@alpha hooks post-edit --file "platform\/scripts\/deploy-app.sh" --memory-key "flow-nexus\/deploy-script" npx claude-flow@alpha hooks post-edit --file "platform\/services\/app.js" --memory-key "flow-nexus\/app" ``` **system-architect Actions:** ```bash # Document deployment process cat > platform\/docs\/DEPLOYMENT.md << 'EOF' # Application Deployment Guide ## Deployment Methods ### 1. Template Deployment Use pre-built templates for quick setup: ```bash mcp__flow-nexus__template_deploy { "template_name": "nextjs-starter", "deployment_name": "my-app" } ``` ### 2. Custom Deployment Deploy custom applications: ```bash .\/platform\/scripts\/deploy-app.sh my-app $SANDBOX_ID ``` ## Deployment Workflow 1. **Prepare**: Build and test locally 2. **Upload**: Transfer files to sandbox 3. **Configure**: Set environment variables 4. **Execute**: Start application 5. **Monitor**: Track health and metrics 6. **Scale**: Adjust resources as needed ## Health Monitoring Check application health: ```bash curl http:\/\/localhost:3000\/health ``` Expected response: ```json { "status": "healthy", "timestamp": "2025-10-30T12:00:00Z", "uptime": 3600 } ``` ## Troubleshooting ### Application Not Starting - Check sandbox logs - Verify environment variables - Ensure dependencies installed - Check port availability ### Health Check Failing - Verify application is running - Check network connectivity - Review error logs - Test locally first ### Performance Issues - Monitor resource usage - Check database connections - Review application logs - Consider scaling up EOF # Post-edit hook npx claude-flow@alpha hooks post-edit --file "platform\/docs\/DEPLOYMENT.md" --memory-key "flow-nexus\/deployment-docs" ``` **Success Criteria:** - [ ] Application deployed from template - [ ] Custom deployment script created - [ ] Health checks configured - [ ] Documentation completed **Memory Persistence:** ```bash npx claude-flow@alpha memory store \ --key "flow-nexus\/phase3-complete" \ --value "{\"status\": \"complete\", \"deployment_id\": \"$DEPLOYMENT_ID\", \"app_running\": true, \"timestamp\": \"$(date -Iseconds)\"}" ``` ## Phase 4: Manage Operations **Objective:** Monitor applications, manage resources, handle scaling and updates **Evidence-Based Validation:** - Monitoring dashboards active - Metrics being collected - Alerts configured - Scaling policies defined **cicd-engineer Actions:** ```bash # Get system health mcp__flow-nexus__system_health # Check sandbox status SANDBOX_ID=$(npx claude-flow@alpha memory retrieve --key "flow-nexus\/sandbox-id" | jq -r '.value') mcp__flow-nexus__sandbox_status { "sandbox_id": "$SANDBOX_ID" } # Get sandbox logs mcp__flow-nexus__sandbox_logs { "sandbox_id": "$SANDBOX_ID", "lines": 100 } # List execution files DEPLOYMENT_ID=$(npx claude-flow@alpha memory retrieve --key "flow-nexus\/deployment-id" | jq -r '.value') mcp__flow-nexus__execution_files_list { "stream_id": "$DEPLOYMENT_ID", "created_by": "claude-code" } # Get audit log USER_ID=$(npx claude-flow@alpha memory retrieve --key "flow-nexus\/user-id" | jq -r '.value') mcp__flow-nexus__audit_log { "user_id": "$USER_ID", "limit": 50 } # Store monitoring data npx claude-flow@alpha memory store \ --key "flow-nexus\/monitoring" \ --value "{\"health\": \"good\", \"sandbox_status\": \"running\", \"log_lines\": 100, \"timestamp\": \"$(date -Iseconds)\"}" ``` **backend-dev Actions:** ```bash # Create monitoring dashboard configuration cat > platform\/config\/monitoring.json << 'EOF' { "dashboards": { "main": { "panels": [ { "title": "Application Health", "type": "status", "metrics": ["uptime", "response_time", "error_rate"] }, { "title": "Resource Usage", "type": "timeseries", "metrics": ["cpu_usage", "memory_usage", "disk_usage"] }, { "title": "Request Metrics", "type": "counter", "metrics": ["requests_total", "requests_per_second"] } ] } }, "alerts": { "high_error_rate": { "threshold": 0.05, "window": "5m", "severity": "critical" }, "high_latency": { "threshold": 1000, "window": "5m", "severity": "warning" }, "resource_exhaustion": { "threshold": 0.9, "window": "10m", "severity": "critical" } } } EOF # Create operations utility script cat > platform\/scripts\/ops-util.sh << 'EOF' #!\/bin\/bash CMD="${1:-help}" SANDBOX_ID="${SANDBOX_ID:-$(npx claude-flow@alpha memory retrieve --key flow-nexus\/sandbox-id | jq -r '.value')}" case "$CMD" in status) echo "Getting system status..." mcp__flow-nexus__system_health ;; logs) echo "Fetching logs for sandbox $SANDBOX_ID..." mcp__flow-nexus__sandbox_logs --sandbox_id="$SANDBOX_ID" --lines=50 ;; restart) echo "Restarting sandbox $SANDBOX_ID..." mcp__flow-nexus__sandbox_stop --sandbox_id="$SANDBOX_ID" sleep 5 .\/platform\/scripts\/deploy-app.sh ;; scale) REPLICAS="${2:-2}" echo "Scaling to $REPLICAS replicas..." # Scaling logic here ;; help) echo "Usage: $0 {status|logs|restart|scale}" ;; *) echo "Unknown command: $CMD" exit 1 ;; esac EOF chmod +x platform\/scripts\/ops-util.sh # Post-edit hooks npx claude-flow@alpha hooks post-edit --file "platform\/config\/monitoring.json" --memory-key "flow-nexus\/monitoring-config" npx claude-flow@alpha hooks post-edit --file "platform\/scripts\/ops-util.sh" --memory-key "flow-nexus\/ops-util" ``` **system-architect Actions:** ```bash # Document operations procedures cat > platform\/docs\/OPERATIONS.md << 'EOF' # Operations Guide ## Monitoring ### Health Checks ```bash # System health mcp__flow-nexus__system_health # Sandbox status mcp__flow-nexus__sandbox_status --sandbox_id=$SANDBOX_ID # Application health curl http:\/\/localhost:3000\/health ``` ### Logs ```bash # View sandbox logs mcp__flow-nexus__sandbox_logs --sandbox_id=$SANDBOX_ID --lines=100 # Stream logs in real-time .\/platform\/scripts\/ops-util.sh logs ``` ### Metrics - **CPU Usage**: Track compute utilization - **Memory Usage**: Monitor memory consumption - **Request Rate**: Requests per second - **Error Rate**: Failed requests percentage - **Latency**: Response time (p50, p95, p99) ## Scaling ### Manual Scaling ```bash # Scale up .\/platform\/scripts\/ops-util.sh scale 3 # Scale down .\/platform\/scripts\/ops-util.sh scale 1 ``` ### Auto-scaling Policies - Scale up when CPU >80% for 5 minutes - Scale down when CPU <20% for 10 minutes - Min replicas: 1 - Max replicas: 10 ## Incident Response ### High Error Rate 1. Check application logs 2. Review recent deployments 3. Verify external dependencies 4. Rollback if necessary ### Performance Degradation 1. Check resource usage 2. Review database queries 3. Analyze slow endpoints 4. Scale resources if needed ### Service Outage 1. Check system health 2. Verify sandbox status 3. Restart application 4. Escalate if persists ## Maintenance ### Updates ```bash # Update dependencies mcp__flow-nexus__sandbox_configure \ --sandbox_id=$SANDBOX_ID \ --install_packages=["package@latest"] # Restart application .\/platform\/scripts\/ops-util.sh restart ``` ### Backups - Automated daily backups - 30-day retention - Point-in-time recovery available EOF # Post-edit hook npx claude-flow@alpha hooks post-edit --file "platform\/docs\/OPERATIONS.md" --memory-key "flow-nexus\/ops-docs" ``` **Success Criteria:** - [ ] Monitoring configured - [ ] Logs accessible - [ ] Operations utilities created - [ ] Incident procedures documented **Memory Persistence:** ```bash npx claude-flow@alpha memory store \ --key "flow-nexus\/phase4-complete" \ --value "{\"status\": \"complete\", \"monitoring\": \"active\", \"ops_tools\": \"ready\", \"timestamp\": \"$(date -Iseconds)\"}" ``` ## Phase 5: Handle Payments **Objective:** Manage credits, configure auto-refill, track usage and billing **Evidence-Based Validation:** - Credit balance retrieved - Payment history accessible - Auto-refill configured - Usage tracking active **cicd-engineer Actions:** ```bash # Check credit balance mcp__flow-nexus__check_balance # Store balance BALANCE="[returned_balance]" npx claude-flow@alpha memory store --key "flow-nexus\/balance" --value "$BALANCE" # Get payment history mcp__flow-nexus__get_payment_history { "limit": 20 } # Configure auto-refill mcp__flow-nexus__configure_auto_refill { "enabled": true, "threshold": 10, "amount": 50 } # Get user statistics USER_ID=$(npx claude-flow@alpha memory retrieve --key "flow-nexus\/user-id" | jq -r '.value') mcp__flow-nexus__user_stats { "user_id": "$USER_ID" } # Notify configuration complete npx claude-flow@alpha hooks notify --message "Payment system configured with auto-refill" ``` **backend-dev Actions:** ```bash # Create billing utility script cat > platform\/scripts\/billing-util.sh << 'EOF' #!\/bin\/bash CMD="${1:-balance}" case "$CMD" in balance) echo "Checking credit balance..." mcp__flow-nexus__check_balance ;; history) LIMIT="${2:-10}" echo "Fetching payment history (last $LIMIT transactions)..." mcp__flow-nexus__get_payment_history --limit=$LIMIT ;; refill) AMOUNT="${2:-50}" echo "Creating payment link for $$AMOUNT..." mcp__flow-nexus__create_payment_link --amount=$AMOUNT ;; auto-refill) ACTION="${2:-status}" if [ "$ACTION" = "enable" ]; then THRESHOLD="${3:-10}" AMOUNT="${4:-50}" mcp__flow-nexus__configure_auto_refill \ --enabled=true \ --threshold=$THRESHOLD \ --amount=$AMOUNT elif [ "$ACTION" = "disable" ]; then mcp__flow-nexus__configure_auto_refill --enabled=false else echo "Current auto-refill status:" mcp__flow-nexus__check_balance | jq '.auto_refill' fi ;; help) echo "Usage: $0 {balance|history|refill|auto-refill}" ;; *) echo "Unknown command: $CMD" exit 1 ;; esac EOF chmod +x platform\/scripts\/billing-util.sh # Post-edit hook npx claude-flow@alpha hooks post-edit --file "platform\/scripts\/billing-util.sh" --memory-key "flow-nexus\/billing-util" # Post-task hook npx claude-flow@alpha hooks post-task --task-id "flow-nexus-platform-setup" ``` **system-architect Actions:** ```bash # Document billing and payments cat > platform\/docs\/BILLING.md << 'EOF' # Billing and Payments Guide ## Credits System Flow Nexus uses a credit-based billing system: - Credits deducted for resource usage - Minimum purchase: $10 - Auto-refill available ## Usage Costs ### Sandboxes - $0.01 per minute (Node.js, Python) - $0.02 per minute (React, Next.js) - Free tier: 100 minutes\/month ### Storage - $0.10 per GB\/month - Free tier: 1 GB ### Workflows - $0.001 per task execution - Free tier: 1000 tasks\/month ### Neural Training - Nano: $0.05\/hour - Small: $0.15\/hour - Medium: $0.50\/hour - Large: $2.00\/hour ## Managing Credits ### Check Balance ```bash .\/platform\/scripts\/billing-util.sh balance ``` ### View History ```bash .\/platform\/scripts\/billing-util.sh history 20 ``` ### Add Credits ```bash .\/platform\/scripts\/billing-util.sh refill 50 ``` ### Auto-Refill Enable automatic credit refills: ```bash .\/platform\/scripts\/billing-util.sh auto-refill enable 10 50 ``` This will automatically add $50 credits when balance falls below $10. Disable auto-refill: ```bash .\/platform\/scripts\/billing-util.sh auto-refill disable ``` ## Cost Optimization 1. **Stop Unused Sandboxes**: Reduce compute costs 2. **Clean Up Storage**: Remove old files 3. **Optimize Workflows**: Reduce task executions 4. **Use Free Tier**: Stay within limits when possible 5. **Monitor Usage**: Track spending regularly ## Billing Alerts Configure alerts for: - Low balance warnings - High usage notifications - Monthly spending limits - Budget thresholds ## Payment Methods Supported payment methods: - Credit\/Debit Cards - PayPal - Wire Transfer (enterprise) ## Invoices Access invoices: ```bash mcp__flow-nexus__get_payment_history --limit=12 ``` Invoices include: - Transaction date - Amount charged - Credits purchased - Usage details EOF # Post-edit hook npx claude-flow@alpha hooks post-edit --file "platform\/docs\/BILLING.md" --memory-key "flow-nexus\/billing-docs" # Session end hook npx claude-flow@alpha hooks session-end --export-metrics true ``` **Success Criteria:** - [ ] Credit balance checked - [ ] Payment history retrieved - [ ] Auto-refill configured - [ ] Billing utilities created - [ ] Documentation completed **Memory Persistence:** ```bash npx claude-flow@alpha memory store \ --key "flow-nexus\/phase5-complete" \ --value "{\"status\": \"complete\", \"balance\": $BALANCE, \"auto_refill\": true, \"timestamp\": \"$(date -Iseconds)\"}" # Final workflow summary npx claude-flow@alpha memory store \ --key "flow-nexus\/workflow-complete" \ --value "{\"status\": \"success\", \"authenticated\": true, \"deployed\": true, \"monitored\": true, \"billing\": \"configured\", \"timestamp\": \"$(date -Iseconds)\"}" ``` ## Workflow Summary **Total Estimated Duration:** 30-60 minutes **Phase Breakdown:** 1. Authentication Setup: 5-10 minutes 2. Configure Services: 10-15 minutes 3. Deploy Applications: 10-15 minutes 4. Manage Operations: 5-10 minutes 5. Handle Payments: 5-10 minutes **Key Deliverables:** - Authenticated user account - Configured platform services - Deployed application - Operations utilities - Billing management - Complete documentation ## Evidence-Based Success Metrics **Authentication:** - User registered and verified - Session token obtained - Profile accessible **Services:** - Sandbox running - Storage configured - Database connected - Real-time subscriptions active **Deployment:** - Application deployed - Health checks passing - Logs accessible **Operations:** - Monitoring active - Metrics collected - Utilities functional **Billing:** - Balance checked - Auto-refill configured - Usage tracked ## Troubleshooting **Authentication Failures:** - Verify email and password - Check network connectivity - Clear browser cache - Try password reset **Sandbox Issues:** - Check sandbox status - Review logs for errors - Verify environment variables - Ensure sufficient credits **Deployment Failures:** - Validate template configuration - Check file permissions - Verify dependencies - Review error messages **Payment Problems:** - Verify payment method - Check credit balance - Review transaction history - Contact support if needed ## Best Practices 1. **Security**: Never commit credentials 2. **Monitoring**: Enable comprehensive logging 3. **Backups**: Regular data backups 4. **Updates**: Keep dependencies current 5. **Testing**: Test before production 6. **Documentation**: Maintain up-to-date docs 7. **Optimization**: Monitor and optimize costs 8. **Support**: Use audit logs for debugging ## References - Flow Nexus Platform: https:\/\/flow-nexus.ruv.io - API Documentation: https:\/\/flow-nexus.ruv.io\/docs - Pricing: https:\/\/flow-nexus.ruv.io\/pricing - Support: https:\/\/flow-nexus.ruv.io\/support