Flow Nexus Platform Management

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

Table of Contents

• 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()

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

• 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

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

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

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.