diegosouzapw Flow Nexus Platform Management
Comprehensive platform management for Flow Nexus - covering authentication, sandbox execution, app deployment, credit management, and coding challenges.
Self-Learning Intelligence
Integrates with RuVector's Q-learning and vector memory for improved performance.
CLI: node .claude/intelligence/cli.js stats
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_statsregularly - 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.