When NOT to Use This Skill

• Local development without cloud infrastructure needs
• Simple scripts that do not require sandboxed execution
• Operations without distributed computing requirements
• Tasks that can run on single-machine environments

Success Criteria

• API response time: <200ms for sandbox creation
• Deployment success rate: >99%
• Sandbox startup time: <5s
• Network latency: <50ms between sandboxes
• Resource utilization: <80% CPU/memory per sandbox
• Uptime: >99.9% for production deployments

Edge Cases & Error Handling

• Rate Limits: Flow Nexus API has request limits; implement queuing and backoff
• Authentication Failures: Validate API tokens before operations; refresh expired tokens
• Network Issues: Retry failed requests with exponential backoff (max 5 retries)
• Quota Exhaustion: Monitor sandbox/compute quotas; alert before limits
• Sandbox Timeouts: Set appropriate timeout values; clean up orphaned sandboxes
• Deployment Failures: Implement rollback strategies; maintain previous working state

Guardrails & Safety

• NEVER expose API keys or authentication tokens in code or logs
• ALWAYS validate responses from Flow Nexus API before processing
• ALWAYS implement timeout limits for long-running operations
• NEVER trust user input for sandbox commands without validation
• ALWAYS monitor resource usage to prevent runaway processes
• ALWAYS clean up sandboxes and resources after task completion

Evidence-Based Validation

• Verify platform health: Check Flow Nexus status endpoint before operations
• Validate deployments: Test sandbox connectivity and functionality
• Monitor costs: Track compute usage and spending against budgets
• Test failure scenarios: Simulate network failures, timeouts, auth errors
• Benchmark performance: Compare actual vs expected latency/throughput

Flow Nexus Platform Management

Gold Tier Skill: Comprehensive platform management for Flow Nexus with 4 automation scripts, 3 configuration templates, and comprehensive test suites - covering authentication, sandbox execution, app deployment, credit management, and coding challenges.

Quick Access

• Scripts: resources/scripts/ - 4 platform automation tools
• Templates: resources/templates/ - 3 configuration templates
• Tests: tests/ - 3 comprehensive test suites
• Process Diagram: flow-nexus-platform-process.dot - Visual workflow

Automation Scripts

This skill includes functional automation scripts for streamlined platform operations:

1. Authentication Manager (auth-manager.js)

Automate user authentication workflows:

# Register new user
node resources/scripts/auth-manager.js register user@example.com SecurePass123 "John Doe"

# Login
node resources/scripts/auth-manager.js login user@example.com SecurePass123

# Check authentication status
node resources/scripts/auth-manager.js status --detailed

# Update profile
node resources/scripts/auth-manager.js update-profile user123 bio="AI Developer" github_username=johndoe

# Upgrade tier
node resources/scripts/auth-manager.js upgrade user123 pro

2. Sandbox Manager (sandbox-manager.js)

Manage sandbox lifecycle with a single script:

# Create sandbox with packages
node resources/scripts/sandbox-manager.js create node my-api --env PORT=3000 NODE_ENV=dev --packages express,cors

# List all sandboxes
node resources/scripts/sandbox-manager.js list --status running

# Execute code
node resources/scripts/sandbox-manager.js execute sbx_123 "console.log('Hello')"
node resources/scripts/sandbox-manager.js execute sbx_123 @script.js

# Upload file
node resources/scripts/sandbox-manager.js upload sbx_123 ./config.json /app/config.json

# View logs
node resources/scripts/sandbox-manager.js logs sbx_123 --lines 100

# Cleanup old sandboxes
node resources/scripts/sandbox-manager.js cleanup-all --older-than-hours 24

3. Deployment Manager (deployment-manager.js)

Automate application deployment:

# Browse templates
node resources/scripts/deployment-manager.js list-templates --category web-api --featured

# Get template details
node resources/scripts/deployment-manager.js template-info express-api-starter

# Deploy application
node resources/scripts/deployment-manager.js deploy express-api-starter my-production-api --var database_url=postgres://...

# Publish your app
node resources/scripts/deployment-manager.js publish "JWT Auth Service" "Production JWT auth" backend ./auth-service.js --tags auth,jwt,security

# Search apps
node resources/scripts/deployment-manager.js search "authentication" --category backend

# View analytics
node resources/scripts/deployment-manager.js analytics app_123 --timeframe 30d

4. Platform Health Monitor (platform-health.js)

Monitor system health and manage credits:

# Check platform health
node resources/scripts/platform-health.js check --detailed

# Check credit balance
node resources/scripts/platform-health.js credits --history

# Create payment link
node resources/scripts/platform-health.js payment-link 50

# Configure auto-refill
node resources/scripts/platform-health.js auto-refill enable --threshold 100 --amount 50

# View audit logs
node resources/scripts/platform-health.js audit-log --limit 100

# Get user statistics
node resources/scripts/platform-health.js user-stats user123

# Market data
node resources/scripts/platform-health.js market-data

Configuration Templates

Three production-ready configuration templates in resources/templates/:

1. Platform Configuration (platform-config.json)

Complete platform settings including authentication, sandboxes, deployment, credits, monitoring, and integrations.

2. Sandbox Configuration (sandbox-config.yaml)

Comprehensive sandbox setup with environment variables, packages, lifecycle hooks, network configuration, and security settings.

3. Deployment Manifest (deployment-manifest.yaml)

Enterprise-grade deployment configuration with autoscaling, health checks, monitoring, CI/CD integration, and rollback strategies.

Table of Contents

1. Authentication & User Management
2. Sandbox Management
3. App Store & Deployment
4. Payments & Credits
5. Challenges & Achievements
6. Storage & Real-time
7. 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()

App Categories

• web-api: RESTful APIs and microservices
• frontend: React, Vue, Angular applications
• full-stack: Complete end-to-end applications
• cli-tools: Command-line utilities
• data-processing: ETL pipelines and analytics
• ml-models: Pre-trained machine learning models
• blockchain: Web3 and blockchain applications
• mobile: React Native and mobile apps

Publishing Best Practices

1. Documentation: Include comprehensive README with setup instructions
2. Examples: Provide usage examples and sample configurations
3. Testing: Include test suite and CI/CD configuration
4. Versioning: Use semantic versioning (MAJOR.MINOR.PATCH)
5. Licensing: Add clear license information (MIT, Apache, etc.)
6. Deployment: Include Docker/docker-compose configurations
7. Migrations: Provide upgrade guides for version updates
8. 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:

1. Complete Challenges: 10-500 credits per challenge
2. Publish Templates: Earn when others deploy (you set pricing)
3. Referral Program: Bonus credits for user invites
4. Daily Login: Small daily bonus (5-10 credits)
5. Achievements: Unlock milestone rewards (50-1000 credits)
6. 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

1. Use Smaller Sandboxes: Choose appropriate templates (base vs full-stack)
2. Optimize Neural Training: Tune hyperparameters, reduce epochs
3. Batch Operations: Group workflow executions together
4. Clean Up Resources: Delete unused sandboxes and storage
5. Monitor Usage: Check user_stats regularly
6. Use Free Templates: Leverage community templates
7. 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

1. Start Simple: Begin with beginner challenges to build confidence
2. Review Solutions: Study top solutions after completing
3. Optimize: Aim for both correctness and performance
4. Daily Practice: Complete daily challenges for bonus credits
5. Community: Engage with discussions and learn from others
6. Track Progress: Monitor achievements and leaderboard position
7. 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

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

Performance

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

Development

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

Cost Management

1. Set auto-refill thresholds carefully
2. Monitor credit usage regularly
3. Complete daily challenges for bonus credits
4. Publish templates to earn passive credits
5. Use free-tier resources when appropriate
6. 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

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
  `
})

// 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"
})

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]
  })
}

// 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
})

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

// 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)

Testing

Comprehensive test suites in tests/:

1. Authentication Manager Tests (auth-manager.test.js)

Tests registration, login, password management, profile updates, and tier upgrades. Includes validation logic, parameter construction, and error handling.

node tests/auth-manager.test.js

2. Sandbox Manager Tests (sandbox-manager.test.js)

Tests sandbox creation, configuration, execution, monitoring, and cleanup. Covers template validation, environment parsing, and resource management.

node tests/sandbox-manager.test.js

3. Platform Integration Tests (platform-integration.test.js)

End-to-end workflow tests combining authentication, sandbox management, deployment, credit management, and health monitoring.

node tests/platform-integration.test.js

Process Flow Diagram

Visual workflow diagram in flow-nexus-platform-process.dot:

• Authentication & User Management phase
• Sandbox Management phase
• Deployment & App Store phase
• Credit & Payment Management phase
• Monitoring & Health phase
• Decision points, warnings, and external tool references

Generate diagram:

dot -Tpng flow-nexus-platform-process.dot -o flow-nexus-platform-process.png

Version History

• v2.0.0 (2025-11-02): Gold Tier Upgrade

  • Added 4 functional automation scripts (auth, sandbox, deployment, health monitoring)
  • Added 3 production-ready configuration templates
  • Added 3 comprehensive test suites (unit + integration)
  • Added GraphViz process flow diagram
  • Added resources README
  • 13 total files (Gold tier: 12+ files)

• 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

Skill Tier: Gold (13 files: 1 SKILL.md + 4 scripts + 3 templates + 3 tests + 1 process diagram + 1 resources README)

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

Core Principles

Flow Nexus Platform operates on 3 fundamental principles:

Principle 1: Cloud-Native Sandbox Isolation

Every execution happens in ephemeral, isolated cloud sandboxes with automatic cleanup and resource management.

In practice:

• Create sandboxes on-demand for development, testing, or production workloads
• Configure environment variables, packages, and startup scripts declaratively
• Destroy sandboxes automatically after timeout or manually to prevent resource leaks
• Upload files, execute code, and monitor logs without affecting host systems

Principle 2: Credit-Based Resource Metering

All platform operations consume rUv credits, enabling transparent cost tracking and optimization.

In practice:

• Monitor credit balance before expensive operations (neural training, long-running sandboxes)
• Configure auto-refill thresholds to prevent service interruptions
• Optimize costs by choosing appropriate sandbox templates and cleaning up unused resources
• Earn credits through challenge completion, template publishing, and referrals

Principle 3: Gamified Developer Engagement

Challenges, achievements, and leaderboards transform platform usage into skill-building experiences.

In practice:

• Complete coding challenges to earn credits and build proficiency
• Publish templates to the app store for passive credit income
• Track progress through achievements (Speed Demon, Code Golf, Streak Master)
• Compete on global and challenge-specific leaderboards

Common Anti-Patterns

Conclusion

The Flow Nexus Platform skill provides comprehensive cloud infrastructure management for AI-assisted development workflows. By combining ephemeral sandbox execution, credit-based metering, and gamified skill-building, it enables scalable development without local infrastructure overhead.

Use this skill when you need isolated execution environments, distributed compute resources, or cloud-based app deployment. The platform shines for teams requiring multi-user collaboration, auto-scaling workloads, or pay-per-use resource models. With 4 automation scripts, 3 production-ready templates, and comprehensive test coverage, this Gold-tier skill delivers enterprise-grade platform orchestration.

Key takeaways: Leverage sandbox templates for consistency, monitor credit usage to optimize costs, and publish successful configurations as templates to build passive credit income. The platform's event-driven architecture, real-time subscriptions, and Queen Seraphina AI assistant provide advanced capabilities for sophisticated workflows.