when-using-flow-nexus-platform-use-flow-nexus-platform

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

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:

# 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:

# 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": "[e-mail]",
  "password": "SecurePassword123!",
  "username": "platform_user",
  "full_name": "Platform User"
}

# Login to create session
mcp__flow-nexus__user_login {
  "email": "[e-mail]",
  "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:

# 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:

# 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": "[e-mail]",
  "password": "secure_password"
}

Login

mcp__flow-nexus__user_login {
  "email": "[e-mail]",
  "password": "secure_password"
}

Logout

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:

# 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": 
}


SUBSCRIPTION_ID=
npx claude-flow@alpha memory store --key  --value 


npx claude-flow@alpha hooks notify --message 

backend-dev Actions:

# 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 (
   UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID NOT NULL,
  name VARCHAR(255) NOT NULL,
  description TEXT,
  status VARCHAR(50) DEFAULT ,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE IF NOT EXISTS deployments (
   UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  application_id UUID REFERENCES applications(),
  version VARCHAR(50) NOT NULL,
  sandbox_id VARCHAR(255),
  status VARCHAR(50) DEFAULT ,
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE IF NOT EXISTS metrics (
   UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  deployment_id UUID REFERENCES deployments(),
  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


npx claude-flow@alpha hooks post-edit --file  --memory-key 

system-architect Actions:

# 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:

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:

# 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:

# 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: ,
    version: ,
    environment: process.env.NODE_ENV
  });
});

app.listen(port, () => {
  console.log(`Server running on port `);
});
EOF


npx claude-flow@alpha hooks post-edit --file  --memory-key 
npx claude-flow@alpha hooks post-edit --file  --memory-key 

system-architect Actions:

# 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:

./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:

curl http://localhost:3000/health

Expected response:

{
  "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:

# 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:

# 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": 
    }
  }
}
EOF


 > platform/scripts/ops-util.sh << 


CMD=
SANDBOX_ID=

  
  status)
     
    mcp__flow-nexus__system_health
    ;;
  logs)
     
    mcp__flow-nexus__sandbox_logs --sandbox_id= --lines=50
    ;;
  restart)
     
    mcp__flow-nexus__sandbox_stop --sandbox_id=
     5
    ./platform/scripts/deploy-app.sh
    ;;
  scale)
    REPLICAS=
     
    
    ;;
  )
     
    ;;
  *)
     
     1
    ;;

EOF

 +x platform/scripts/ops-util.sh


npx claude-flow@alpha hooks post-edit --file  --memory-key 
npx claude-flow@alpha hooks post-edit --file  --memory-key 

system-architect Actions:

# 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

# 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

# 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

# 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:

# 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:

# 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 
      mcp__flow-nexus__check_balance | jq 
    
    ;;
  )
     
    ;;
  *)
     
     1
    ;;

EOF

 +x platform/scripts/billing-util.sh


npx claude-flow@alpha hooks post-edit --file  --memory-key 


npx claude-flow@alpha hooks post-task --task-id 

system-architect Actions:

# 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

./platform/scripts/billing-util.sh history 20

Add Credits

./platform/scripts/billing-util.sh refill 50

Auto-Refill

Enable automatic credit refills:

./platform/scripts/billing-util.sh auto-refill enable 10 50

This will automatically add $50 credits when balance falls below $10.

Disable auto-refill:

./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:

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