flow-nexus-platform

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

mcp__flow-nexus__auth_status({ detailed: true })

mcp__flow-nexus__user_logout()

mcp__flow-nexus__user_reset_password({
  email: "user@example.com"
})

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

mcp__flow-nexus__user_verify_email({
  token: "verification_token_from_email"
})

mcp__flow-nexus__user_profile({
  user_id: "your_user_id"
})

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

mcp__flow-nexus__user_stats({
  user_id: "your_user_id"
})

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

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

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

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

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

mcp__flow-nexus__sandbox_status({
  sandbox_id: "sandbox_id"
})

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

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

mcp__flow-nexus__sandbox_stop({
  sandbox_id: "sandbox_id"
})

mcp__flow-nexus__sandbox_delete({
  sandbox_id: "sandbox_id"
})

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

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

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

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

mcp__flow-nexus__app_get({
  app_id: "app_id"
})

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

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

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

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

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

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

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

mcp__flow-nexus__app_installed({
  user_id: "your_user_id"
})

mcp__flow-nexus__market_data()

mcp__flow-nexus__check_balance()

mcp__flow-nexus__ruv_balance({
  user_id: "your_user_id"
})

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

mcp__flow-nexus__get_payment_history({
  limit: 50
})

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

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

mcp__flow-nexus__configure_auto_refill({
  enabled: false
})

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

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

mcp__flow-nexus__challenge_get({
  challenge_id: "two-sum-problem"
})

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

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

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

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

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

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

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

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

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

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

mcp__flow-nexus__realtime_list()

mcp__flow-nexus__realtime_unsubscribe({
  subscription_id: "subscription_id"
})

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

mcp__flow-nexus__execution_stream_status({
  stream_id: "stream_id"
})

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

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

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

mcp__flow-nexus__system_health()

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

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

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

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

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

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

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

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)