name	flow-nexus-platform
description	Comprehensive Flow Nexus platform management - authentication, sandboxes, app deployment, payments, and challenges
category	platform
version	1.0.0
author	Flow Nexus
tags	authentication, sandboxes, deployment, payments, gamification, cloud

Flow Nexus Platform Management

Comprehensive platform management for Flow Nexus - covering authentication, sandbox execution, app deployment, credit management, and coding challenges.

Authentication & User Management
Sandbox Management
App Store & Deployment
Payments & Credits
Challenges & Achievements
Storage & Real-time
System Utilities

Authentication & User Management

Registration & Login

Register New Account

mcp__flow -
  nexus__user_register({
    email: 'user@example.com',
    password: 'secure_password',
    full_name: 'Your Name',
    username: 'unique_username', // optional
  });

Login

mcp__flow -
  nexus__user_login({
    email: 'user@example.com',
    password: 'your_password',
  });

Check Authentication Status

mcp__flow - nexus__auth_status({ detailed: true });

Logout

mcp__flow - nexus__user_logout();

Password Management

Request Password Reset

mcp__flow -
  nexus__user_reset_password({
    email: 'user@example.com',
  });

Update Password with Token

mcp__flow -
  nexus__user_update_password({
    token: 'reset_token_from_email',
    new_password: 'new_secure_password',
  });

Verify Email

mcp__flow -
  nexus__user_verify_email({
    token: 'verification_token_from_email',
  });

Profile Management

Get User Profile

mcp__flow -
  nexus__user_profile({
    user_id: 'your_user_id',
  });

Update Profile

mcp__flow -
  nexus__user_update_profile({
    user_id: 'your_user_id',
    updates: {
      full_name: 'Updated Name',
      bio: 'AI Developer and researcher',
      github_username: 'yourusername',
      twitter_handle: '@yourhandle',
    },
  });

Get User Statistics

mcp__flow -
  nexus__user_stats({
    user_id: 'your_user_id',
  });

Upgrade User Tier

mcp__flow -
  nexus__user_upgrade({
    user_id: 'your_user_id',
    tier: 'pro', // pro, enterprise
  });

Sandbox Management

Create & Configure Sandboxes

Create Sandbox

mcp__flow -
  nexus__sandbox_create({
    template: 'node', // node, python, react, nextjs, vanilla, base, claude-code
    name: 'my-sandbox',
    env_vars: {
      API_KEY: 'your_api_key',
      NODE_ENV: 'development',
      DATABASE_URL: 'postgres://...',
    },
    install_packages: ['express', 'cors', 'dotenv'],
    startup_script: 'npm run dev',
    timeout: 3600, // seconds
    metadata: {
      project: 'my-project',
      environment: 'staging',
    },
  });

Configure Existing Sandbox

mcp__flow -
  nexus__sandbox_configure({
    sandbox_id: 'sandbox_id',
    env_vars: {
      NEW_VAR: 'value',
    },
    install_packages: ['axios', 'lodash'],
    run_commands: ['npm run migrate', 'npm run seed'],
    anthropic_key: 'sk-ant-...', // For Claude Code integration
  });

Execute Code

Run Code in Sandbox

mcp__flow -
  nexus__sandbox_execute({
    sandbox_id: 'sandbox_id',
    code: `
    console.log('Hello from sandbox!');
    const result = await fetch('https://api.example.com/data');
    const data = await result.json();
    return data;
  `,
    language: 'javascript',
    capture_output: true,
    timeout: 60, // seconds
    working_dir: '/app',
    env_vars: {
      TEMP_VAR: 'override',
    },
  });

Manage Sandboxes

List Sandboxes

mcp__flow -
  nexus__sandbox_list({
    status: 'running', // running, stopped, all
  });

Get Sandbox Status

mcp__flow -
  nexus__sandbox_status({
    sandbox_id: 'sandbox_id',
  });

Upload File to Sandbox

mcp__flow -
  nexus__sandbox_upload({
    sandbox_id: 'sandbox_id',
    file_path: '/app/config/database.json',
    content: JSON.stringify(databaseConfig, null, 2),
  });

Get Sandbox Logs

mcp__flow -
  nexus__sandbox_logs({
    sandbox_id: 'sandbox_id',
    lines: 100, // max 1000
  });

Stop Sandbox

mcp__flow -
  nexus__sandbox_stop({
    sandbox_id: 'sandbox_id',
  });

Delete Sandbox

mcp__flow -
  nexus__sandbox_delete({
    sandbox_id: 'sandbox_id',
  });

Sandbox Templates

node: Node.js environment with npm
python: Python 3.x with pip
react: React development setup
nextjs: Next.js full-stack framework
vanilla: Basic HTML/CSS/JS
base: Minimal Linux environment
claude-code: Claude Code integrated environment

Common Sandbox Patterns

API Development Sandbox

mcp__flow -
  nexus__sandbox_create({
    template: 'node',
    name: 'api-development',
    install_packages: ['express', 'cors', 'helmet', 'dotenv', 'jsonwebtoken', 'bcrypt'],
    env_vars: {
      PORT: '3000',
      NODE_ENV: 'development',
    },
    startup_script: 'npm run dev',
  });

Machine Learning Sandbox

mcp__flow -
  nexus__sandbox_create({
    template: 'python',
    name: 'ml-training',
    install_packages: ['numpy', 'pandas', 'scikit-learn', 'matplotlib', 'tensorflow'],
    env_vars: {
      CUDA_VISIBLE_DEVICES: '0',
    },
  });

Full-Stack Development

mcp__flow -
  nexus__sandbox_create({
    template: 'nextjs',
    name: 'fullstack-app',
    install_packages: ['prisma', '@prisma/client', 'next-auth', 'zod'],
    env_vars: {
      DATABASE_URL: 'postgresql://...',
      NEXTAUTH_SECRET: 'secret',
    },
  });

App Store & Deployment

Browse & Search

Search Applications

mcp__flow -
  nexus__app_search({
    search: 'authentication api',
    category: 'backend',
    featured: true,
    limit: 20,
  });

Get App Details

mcp__flow -
  nexus__app_get({
    app_id: 'app_id',
  });

List Templates

mcp__flow -
  nexus__app_store_list_templates({
    category: 'web-api',
    tags: ['express', 'jwt', 'typescript'],
    limit: 20,
  });

Get Template Details

mcp__flow -
  nexus__template_get({
    template_name: 'express-api-starter',
    template_id: 'template_id', // alternative
  });

List All Available Templates

mcp__flow -
  nexus__template_list({
    category: 'backend',
    template_type: 'starter',
    featured: true,
    limit: 50,
  });

Publish Applications

Publish App to Store

mcp__flow -
  nexus__app_store_publish_app({
    name: 'JWT Authentication Service',
    description: 'Production-ready JWT authentication microservice with refresh tokens',
    category: 'backend',
    version: '1.0.0',
    source_code: sourceCodeString,
    tags: ['auth', 'jwt', 'express', 'typescript', 'security'],
    metadata: {
      author: 'Your Name',
      license: 'MIT',
      repository: 'github.com/username/repo',
      homepage: 'https://yourapp.com',
      documentation: 'https://docs.yourapp.com',
    },
  });

Update Application

mcp__flow -
  nexus__app_update({
    app_id: 'app_id',
    updates: {
      version: '1.1.0',
      description: 'Added OAuth2 support',
      tags: ['auth', 'jwt', 'oauth2', 'express'],
      source_code: updatedSourceCode,
    },
  });

Deploy Templates

Deploy Template

mcp__flow -
  nexus__template_deploy({
    template_name: 'express-api-starter',
    deployment_name: 'my-production-api',
    variables: {
      api_key: 'your_api_key',
      database_url: 'postgres://user:pass@host:5432/db',
      redis_url: 'redis://localhost:6379',
    },
    env_vars: {
      NODE_ENV: 'production',
      PORT: '8080',
      LOG_LEVEL: 'info',
    },
  });

Analytics & Management

Get App Analytics

mcp__flow -
  nexus__app_analytics({
    app_id: 'your_app_id',
    timeframe: '30d', // 24h, 7d, 30d, 90d
  });

View Installed Apps

mcp__flow -
  nexus__app_installed({
    user_id: 'your_user_id',
  });

Get Market Statistics

mcp__flow - nexus__market_data();

Publishing Best Practices

Documentation: Include comprehensive README with setup instructions
Examples: Provide usage examples and sample configurations
Testing: Include test suite and CI/CD configuration
Versioning: Use semantic versioning (MAJOR.MINOR.PATCH)
Licensing: Add clear license information (MIT, Apache, etc.)
Deployment: Include Docker/docker-compose configurations
Migrations: Provide upgrade guides for version updates
Security: Document security considerations and best practices

Revenue Sharing

Earn rUv credits when others deploy your templates
Set pricing (0 for free, or credits for premium)
Track usage and earnings via analytics
Withdraw credits or use for Flow Nexus services

Payments & Credits

Balance & Credits

Check Credit Balance

mcp__flow - nexus__check_balance();

Check rUv Balance

mcp__flow -
  nexus__ruv_balance({
    user_id: 'your_user_id',
  });

View Transaction History

mcp__flow -
  nexus__ruv_history({
    user_id: 'your_user_id',
    limit: 100,
  });

Get Payment History

mcp__flow -
  nexus__get_payment_history({
    limit: 50,
  });

Purchase Credits

Create Payment Link

mcp__flow -
  nexus__create_payment_link({
    amount: 50, // USD, minimum $10
  });
// Returns secure Stripe payment URL

Auto-Refill Configuration

Enable Auto-Refill

mcp__flow -
  nexus__configure_auto_refill({
    enabled: true,
    threshold: 100, // Refill when credits drop below 100
    amount: 50, // Purchase $50 worth of credits
  });

Disable Auto-Refill

mcp__flow -
  nexus__configure_auto_refill({
    enabled: false,
  });

Credit Pricing

Service Costs:

Swarm Operations: 1-10 credits/hour
Sandbox Execution: 0.5-5 credits/hour
Neural Training: 5-50 credits/job
Workflow Runs: 0.1-1 credit/execution
Storage: 0.01 credits/GB/day
API Calls: 0.001-0.01 credits/request

Earning Credits

Ways to Earn:

Complete Challenges: 10-500 credits per challenge
Publish Templates: Earn when others deploy (you set pricing)
Referral Program: Bonus credits for user invites
Daily Login: Small daily bonus (5-10 credits)
Achievements: Unlock milestone rewards (50-1000 credits)
App Store Sales: Revenue share from paid templates

Earn Credits Programmatically

mcp__flow -
  nexus__app_store_earn_ruv({
    user_id: 'your_user_id',
    amount: 100,
    reason: 'Completed expert algorithm challenge',
    source: 'challenge', // challenge, app_usage, referral, etc.
  });

Subscription Tiers

Free Tier

100 free credits monthly
Basic sandbox access (2 concurrent)
Limited swarm agents (3 max)
Community support
1GB storage

Pro Tier ($29/month)

1000 credits monthly
Priority sandbox access (10 concurrent)
Unlimited swarm agents
Advanced workflows
Email support
10GB storage
Early access to features

Enterprise Tier (Custom Pricing)

Unlimited credits
Dedicated compute resources
Custom neural models
99.9% SLA guarantee
Priority 24/7 support
Unlimited storage
White-label options
On-premise deployment

Cost Optimization Tips

Use Smaller Sandboxes: Choose appropriate templates (base vs full-stack)
Optimize Neural Training: Tune hyperparameters, reduce epochs
Batch Operations: Group workflow executions together
Clean Up Resources: Delete unused sandboxes and storage
Monitor Usage: Check user_stats regularly
Use Free Templates: Leverage community templates
Schedule Off-Peak: Run heavy jobs during low-cost periods

Challenges & Achievements

Browse Challenges

List Available Challenges

mcp__flow -
  nexus__challenges_list({
    difficulty: 'intermediate', // beginner, intermediate, advanced, expert
    category: 'algorithms',
    status: 'active', // active, completed, locked
    limit: 20,
  });

Get Challenge Details

mcp__flow -
  nexus__challenge_get({
    challenge_id: 'two-sum-problem',
  });

Submit Solutions

Submit Challenge Solution

mcp__flow -
  nexus__challenge_submit({
    challenge_id: 'challenge_id',
    user_id: 'your_user_id',
    solution_code: `
    function twoSum(nums, target) {
      const map = new Map();
      for (let i = 0; i < nums.length; i++) {
        const complement = target - nums[i];
        if (map.has(complement)) {
          return [map.get(complement), i];
        }
        map.set(nums[i], i);
      }
      return [];
    }
  `,
    language: 'javascript',
    execution_time: 45, // milliseconds (optional)
  });

Mark Challenge as Complete

mcp__flow -
  nexus__app_store_complete_challenge({
    challenge_id: 'challenge_id',
    user_id: 'your_user_id',
    submission_data: {
      passed_tests: 10,
      total_tests: 10,
      execution_time: 45,
      memory_usage: 2048, // KB
    },
  });

Leaderboards

Global Leaderboard

mcp__flow -
  nexus__leaderboard_get({
    type: 'global', // global, weekly, monthly, challenge
    limit: 100,
  });

Challenge-Specific Leaderboard

mcp__flow -
  nexus__leaderboard_get({
    type: 'challenge',
    challenge_id: 'specific_challenge_id',
    limit: 50,
  });

Achievements & Badges

List User Achievements

mcp__flow -
  nexus__achievements_list({
    user_id: 'your_user_id',
    category: 'speed_demon', // Optional filter
  });

Challenge Categories

algorithms: Classic algorithm problems (sorting, searching, graphs)
data-structures: DS implementation (trees, heaps, tries)
system-design: Architecture and scalability challenges
optimization: Performance and efficiency problems
security: Security-focused vulnerabilities and fixes
ml-basics: Machine learning fundamentals
distributed-systems: Concurrency and distributed computing
databases: Query optimization and schema design

Challenge Difficulty Rewards

Beginner: 10-25 credits
Intermediate: 50-100 credits
Advanced: 150-300 credits
Expert: 400-500 credits
Master: 600-1000 credits

Achievement Types

Speed Demon: Complete challenges in record time
Code Golf: Minimize code length
Perfect Score: 100% test pass rate
Streak Master: Complete challenges N days in a row
Polyglot: Solve in multiple languages
Debugger: Fix broken code challenges
Optimizer: Achieve top performance benchmarks

Tips for Success

Start Simple: Begin with beginner challenges to build confidence
Review Solutions: Study top solutions after completing
Optimize: Aim for both correctness and performance
Daily Practice: Complete daily challenges for bonus credits
Community: Engage with discussions and learn from others
Track Progress: Monitor achievements and leaderboard position
Experiment: Try multiple approaches to problems

Storage & Real-time

File Storage

Upload File

mcp__flow -
  nexus__storage_upload({
    bucket: 'my-bucket', // public, private, shared, temp
    path: 'data/users.json',
    content: JSON.stringify(userData, null, 2),
    content_type: 'application/json',
  });

List Files

mcp__flow -
  nexus__storage_list({
    bucket: 'my-bucket',
    path: 'data/', // prefix filter
    limit: 100,
  });

Get Public URL

mcp__flow -
  nexus__storage_get_url({
    bucket: 'my-bucket',
    path: 'data/report.pdf',
    expires_in: 3600, // seconds (default: 1 hour)
  });

Delete File

mcp__flow -
  nexus__storage_delete({
    bucket: 'my-bucket',
    path: 'data/old-file.json',
  });

Storage Buckets

public: Publicly accessible files (CDN-backed)
private: User-only access with authentication
shared: Team collaboration with ACL
temp: Auto-deleted after 24 hours

Real-time Subscriptions

Subscribe to Database Changes

mcp__flow -
  nexus__realtime_subscribe({
    table: 'tasks',
    event: 'INSERT', // INSERT, UPDATE, DELETE, *
    filter: 'status=eq.pending AND priority=eq.high',
  });

List Active Subscriptions

mcp__flow - nexus__realtime_list();

Unsubscribe

mcp__flow -
  nexus__realtime_unsubscribe({
    subscription_id: 'subscription_id',
  });

Execution Monitoring

Subscribe to Execution Stream

mcp__flow -
  nexus__execution_stream_subscribe({
    stream_type: 'claude-flow-swarm', // claude-code, claude-flow-swarm, claude-flow-hive-mind, github-integration
    deployment_id: 'deployment_id',
    sandbox_id: 'sandbox_id', // alternative
  });

Get Stream Status

mcp__flow -
  nexus__execution_stream_status({
    stream_id: 'stream_id',
  });

List Generated Files

mcp__flow -
  nexus__execution_files_list({
    stream_id: 'stream_id',
    created_by: 'claude-flow', // claude-code, claude-flow, git-clone, user
    file_type: 'javascript', // filter by extension
  });

Get File Content from Execution

mcp__flow -
  nexus__execution_file_get({
    file_id: 'file_id',
    file_path: '/path/to/file.js', // alternative
  });

System Utilities

Queen Seraphina AI Assistant

Seek Guidance from Seraphina

mcp__flow -
  nexus__seraphina_chat({
    message: 'How should I architect a distributed microservices system?',
    enable_tools: true, // Allow her to create swarms, deploy code, etc.
    conversation_history: [
      { role: 'user', content: 'I need help with system architecture' },
      { role: 'assistant', content: 'I can help you design that. What are your requirements?' },
    ],
  });

Queen Seraphina is an advanced AI assistant with:

Deep expertise in distributed systems
Ability to create swarms and orchestrate agents
Code deployment and architecture design
Multi-turn conversation with context retention
Tool usage for hands-on assistance

System Health & Monitoring

Check System Health

mcp__flow - nexus__system_health();

View Audit Logs

mcp__flow -
  nexus__audit_log({
    user_id: 'your_user_id', // optional filter
    limit: 100,
  });

Authentication Management

Initialize Authentication

mcp__flow -
  nexus__auth_init({
    mode: 'user', // user, service
  });

Quick Start Guide

Step 1: Register & Login

// Register
mcp__flow -
  nexus__user_register({
    email: 'dev@example.com',
    password: 'SecurePass123!',
    full_name: 'Developer Name',
  });

// Login
mcp__flow -
  nexus__user_login({
    email: 'dev@example.com',
    password: 'SecurePass123!',
  });

// Check auth status
mcp__flow - nexus__auth_status({ detailed: true });

Step 2: Configure Billing

// Check current balance
mcp__flow - nexus__check_balance();

// Add credits
const paymentLink =
  mcp__flow -
  nexus__create_payment_link({
    amount: 50, // $50
  });

// Setup auto-refill
mcp__flow -
  nexus__configure_auto_refill({
    enabled: true,
    threshold: 100,
    amount: 50,
  });

Step 3: Create Your First Sandbox

// Create development sandbox
const sandbox =
  mcp__flow -
  nexus__sandbox_create({
    template: 'node',
    name: 'dev-environment',
    install_packages: ['express', 'dotenv'],
    env_vars: {
      NODE_ENV: 'development',
    },
  });

// Execute code
mcp__flow -
  nexus__sandbox_execute({
    sandbox_id: sandbox.id,
    code: 'console.log("Hello Flow Nexus!")',
    language: 'javascript',
  });

Step 4: Deploy an App

// Browse templates
mcp__flow -
  nexus__template_list({
    category: 'backend',
    featured: true,
  });

// Deploy template
mcp__flow -
  nexus__template_deploy({
    template_name: 'express-api-starter',
    deployment_name: 'my-api',
    variables: {
      database_url: 'postgres://...',
    },
  });

Step 5: Complete a Challenge

// Find challenges
mcp__flow -
  nexus__challenges_list({
    difficulty: 'beginner',
    category: 'algorithms',
  });

// Submit solution
mcp__flow -
  nexus__challenge_submit({
    challenge_id: 'fizzbuzz',
    user_id: 'your_id',
    solution_code: '...',
    language: 'javascript',
  });

Best Practices

Security

Never hardcode API keys - use environment variables
Enable 2FA when available
Regularly rotate passwords and tokens
Use private buckets for sensitive data
Review audit logs periodically
Set appropriate file expiration times

Performance

Clean up unused sandboxes to save credits
Use smaller sandbox templates when possible
Optimize storage by deleting old files
Batch operations to reduce API calls
Monitor usage via user_stats
Use temp buckets for transient data

Development

Start with sandbox testing before deployment
Version your applications semantically
Document all templates thoroughly
Include tests in published apps
Use execution monitoring for debugging
Leverage real-time subscriptions for live updates

Cost Management

Set auto-refill thresholds carefully
Monitor credit usage regularly
Complete daily challenges for bonus credits
Publish templates to earn passive credits
Use free-tier resources when appropriate
Schedule heavy jobs during off-peak times

Troubleshooting

Authentication Issues

Login Failed: Check email/password, verify email first
Token Expired: Re-login to get fresh tokens
Permission Denied: Check tier limits, upgrade if needed

Sandbox Issues

Sandbox Won't Start: Check template compatibility, verify credits
Execution Timeout: Increase timeout parameter or optimize code
Out of Memory: Use larger template or optimize memory usage
Package Install Failed: Check package name, verify npm/pip availability

Payment Issues

Payment Failed: Check payment method, sufficient funds
Credits Not Applied: Allow 5-10 minutes for processing
Auto-refill Not Working: Verify payment method on file

Challenge Issues

Submission Rejected: Check code syntax, ensure all tests pass
Wrong Answer: Review test cases, check edge cases
Performance Too Slow: Optimize algorithm complexity

Support & Resources

Documentation: https://docs.flow-nexus.ruv.io
API Reference: https://api.flow-nexus.ruv.io/docs
Status Page: https://status.flow-nexus.ruv.io
Community Forum: https://community.flow-nexus.ruv.io
GitHub Issues: https://github.com/ruvnet/flow-nexus/issues
Discord: https://discord.gg/flow-nexus
Email Support: support@flow-nexus.ruv.io (Pro/Enterprise only)

Progressive Disclosure

Advanced Sandbox Configuration

Custom Docker Images

mcp__flow -
  nexus__sandbox_create({
    template: 'base',
    name: 'custom-environment',
    startup_script: `
    apt-get update
    apt-get install -y custom-package
    git clone https://github.com/user/repo
    cd repo && npm install
  `,
  });

Multi-Stage Execution

// Stage 1: Setup
mcp__flow -
  nexus__sandbox_execute({
    sandbox_id: 'id',
    code: 'npm install && npm run build',
  });

// Stage 2: Run
mcp__flow -
  nexus__sandbox_execute({
    sandbox_id: 'id',
    code: 'npm start',
    working_dir: '/app/dist',
  });

Advanced Storage Patterns

Large File Upload (Chunked)

const chunkSize = 5 * 1024 * 1024; // 5MB chunks
for (let i = 0; i < chunks.length; i++) {
  (await mcp__flow) -
    nexus__storage_upload({
      bucket: 'private',
      path: `large-file.bin.part${i}`,
      content: chunks[i],
    });
}

Storage Lifecycle

// Upload to temp for processing
mcp__flow -
  nexus__storage_upload({
    bucket: 'temp',
    path: 'processing/data.json',
    content: data,
  });

// Move to permanent storage after processing
mcp__flow -
  nexus__storage_upload({
    bucket: 'private',
    path: 'archive/processed-data.json',
    content: processedData,
  });

Advanced Real-time Patterns

Multi-Table Sync

const tables = ['users', 'tasks', 'notifications'];
tables.forEach((table) => {
  mcp__flow -
    nexus__realtime_subscribe({
      table,
      event: '*',
      filter: `user_id=eq.${userId}`,
    });
});

Event-Driven Workflows

// Subscribe to task completion
mcp__flow -
  nexus__realtime_subscribe({
    table: 'tasks',
    event: 'UPDATE',
    filter: 'status=eq.completed',
  });

// Trigger notification workflow on event
// (handled by your application logic)

Version History

v1.0.0 (2025-10-19): Initial comprehensive platform skill
- Authentication & user management
- Sandbox creation and execution
- App store and deployment
- Payments and credits
- Challenges and achievements
- Storage and real-time features
- System utilities and Queen Seraphina integration

This skill consolidates 6 Flow Nexus command modules into a single comprehensive platform management interface.

Install Skill

SKILL.md