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

What this skill does

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

# Login to create session
mcp__flow-nexus__user_login {
  "email": "[email protected]",
  "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": "[email protected]",
  "password": "secure_password"
}
```

### Login
```bash
mcp__flow-nexus__user_login {
  "email": "[email protected]",
  "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