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

Comprehensive Flow Nexus platform management covering authentication, sandboxes, storage, databases, app deployment, payments, and monitoring. This SOP provides end-to-end platform operations.

install

source · Clone the upstream repo

git clone https://github.com/aiskillstore/marketplace

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/aiskillstore/marketplace "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/dnyoussef/when-using-flow-nexus-platform-use-flow-nexus-platform" ~/.claude/skills/aiskillstore-marketplace-when-using-flow-nexus-platform-use-flow-nexus-platform && rm -rf "$T"

manifest: skills/dnyoussef/when-using-flow-nexus-platform-use-flow-nexus-platform/SKILL.md

source content

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

# 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": "user@example.com",
  "password": "secure_password"
}

Login

mcp__flow-nexus__user_login {
  "email": "user@example.com",
  "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": "*"
}

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

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

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

# 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

Prepare: Build and test locally
Upload: Transfer files to sandbox
Configure: Set environment variables
Execute: Start application
Monitor: Track health and metrics
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": "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:

# 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

Check application logs
Review recent deployments
Verify external dependencies
Rollback if necessary

Performance Degradation

Check resource usage
Review database queries
Analyze slow endpoints
Scale resources if needed

Service Outage

Check system health
Verify sandbox status
Restart application
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 "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:

# 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

Stop Unused Sandboxes: Reduce compute costs
Clean Up Storage: Remove old files
Optimize Workflows: Reduce task executions
Use Free Tier: Stay within limits when possible
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:

Authentication Setup: 5-10 minutes
Configure Services: 10-15 minutes
Deploy Applications: 10-15 minutes
Manage Operations: 5-10 minutes
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

Security: Never commit credentials
Monitoring: Enable comprehensive logging
Backups: Regular data backups
Updates: Keep dependencies current
Testing: Test before production
Documentation: Maintain up-to-date docs
Optimization: Monitor and optimize costs
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