# Flow Nexus Platform

> Comprehensive Flow Nexus platform management - authentication, sandboxes, app deployment, payments, and challenges

- **Type:** Skill
- **Install:** `agentstack add skill-proffesor-for-testing-agentic-qe-flow-nexus-platform`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [proffesor-for-testing](https://agentstack.voostack.com/s/proffesor-for-testing)
- **Installs:** 0
- **Category:** [Finance & Payments](https://agentstack.voostack.com/c/finance-and-payments)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [proffesor-for-testing](https://github.com/proffesor-for-testing)
- **Source:** https://github.com/proffesor-for-testing/agentic-qe/tree/main/.claude/skills/flow-nexus-platform
- **Website:** https://agentic-qe.dev/

## Install

```sh
agentstack add skill-proffesor-for-testing-agentic-qe-flow-nexus-platform
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Flow Nexus Platform Management

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

## Table of Contents
1. [Authentication & User Management](#authentication--user-management)
2. [Sandbox Management](#sandbox-management)
3. [App Store & Deployment](#app-store--deployment)
4. [Payments & Credits](#payments--credits)
5. [Challenges & Achievements](#challenges--achievements)
6. [Storage & Real-time](#storage--real-time)
7. [System Utilities](#system-utilities)

---

## Authentication & User Management

### Registration & Login

**Register New Account**
```javascript
mcp__flow-nexus__user_register({
  email: "user@example.com",
  password: "secure_password",
  full_name: "Your Name",
  username: "unique_username" // optional
})
```

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

**Check Authentication Status**
```javascript
mcp__flow-nexus__auth_status({ detailed: true })
```

**Logout**
```javascript
mcp__flow-nexus__user_logout()
```

### Password Management

**Request Password Reset**
```javascript
mcp__flow-nexus__user_reset_password({
  email: "user@example.com"
})
```

**Update Password with Token**
```javascript
mcp__flow-nexus__user_update_password({
  token: "reset_token_from_email",
  new_password: "new_secure_password"
})
```

**Verify Email**
```javascript
mcp__flow-nexus__user_verify_email({
  token: "verification_token_from_email"
})
```

### Profile Management

**Get User Profile**
```javascript
mcp__flow-nexus__user_profile({
  user_id: "your_user_id"
})
```

**Update Profile**
```javascript
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**
```javascript
mcp__flow-nexus__user_stats({
  user_id: "your_user_id"
})
```

**Upgrade User Tier**
```javascript
mcp__flow-nexus__user_upgrade({
  user_id: "your_user_id",
  tier: "pro" // pro, enterprise
})
```

---

## Sandbox Management

### Create & Configure Sandboxes

**Create Sandbox**
```javascript
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**
```javascript
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**
```javascript
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**
```javascript
mcp__flow-nexus__sandbox_list({
  status: "running" // running, stopped, all
})
```

**Get Sandbox Status**
```javascript
mcp__flow-nexus__sandbox_status({
  sandbox_id: "sandbox_id"
})
```

**Upload File to Sandbox**
```javascript
mcp__flow-nexus__sandbox_upload({
  sandbox_id: "sandbox_id",
  file_path: "/app/config/database.json",
  content: JSON.stringify(databaseConfig, null, 2)
})
```

**Get Sandbox Logs**
```javascript
mcp__flow-nexus__sandbox_logs({
  sandbox_id: "sandbox_id",
  lines: 100 // max 1000
})
```

**Stop Sandbox**
```javascript
mcp__flow-nexus__sandbox_stop({
  sandbox_id: "sandbox_id"
})
```

**Delete Sandbox**
```javascript
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**
```javascript
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**
```javascript
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**
```javascript
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**
```javascript
mcp__flow-nexus__app_search({
  search: "authentication api",
  category: "backend",
  featured: true,
  limit: 20
})
```

**Get App Details**
```javascript
mcp__flow-nexus__app_get({
  app_id: "app_id"
})
```

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

**Get Template Details**
```javascript
mcp__flow-nexus__template_get({
  template_name: "express-api-starter",
  template_id: "template_id" // alternative
})
```

**List All Available Templates**
```javascript
mcp__flow-nexus__template_list({
  category: "backend",
  template_type: "starter",
  featured: true,
  limit: 50
})
```

### Publish Applications

**Publish App to Store**
```javascript
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**
```javascript
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**
```javascript
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**
```javascript
mcp__flow-nexus__app_analytics({
  app_id: "your_app_id",
  timeframe: "30d" // 24h, 7d, 30d, 90d
})
```

**View Installed Apps**
```javascript
mcp__flow-nexus__app_installed({
  user_id: "your_user_id"
})
```

**Get Market Statistics**
```javascript
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**
```javascript
mcp__flow-nexus__check_balance()
```

**Check rUv Balance**
```javascript
mcp__flow-nexus__ruv_balance({
  user_id: "your_user_id"
})
```

**View Transaction History**
```javascript
mcp__flow-nexus__ruv_history({
  user_id: "your_user_id",
  limit: 100
})
```

**Get Payment History**
```javascript
mcp__flow-nexus__get_payment_history({
  limit: 50
})
```

### Purchase Credits

**Create Payment Link**
```javascript
mcp__flow-nexus__create_payment_link({
  amount: 50 // USD, minimum $10
})
// Returns secure Stripe payment URL
```

### Auto-Refill Configuration

**Enable Auto-Refill**
```javascript
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**
```javascript
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**
```javascript
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**
```javascript
mcp__flow-nexus__challenges_list({
  difficulty: "intermediate", // beginner, intermediate, advanced, expert
  category: "algorithms",
  status: "active", // active, completed, locked
  limit: 20
})
```

**Get Challenge Details**
```javascript
mcp__flow-nexus__challenge_get({
  challenge_id: "two-sum-problem"
})
```

### Submit Solutions

**Submit Challenge Solution**
```javascript
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 
Advanced Sandbox Configuration

### Custom Docker Images
```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
  `
})
```

### Multi-Stage Execution
```javascript
// 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)
```javascript
const chunkSize = 5 * 1024 * 1024 // 5MB chunks
for (let i = 0; i 

Advanced Real-time Patterns

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

### Event-Driven Workflows
```javascript
// 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.*

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [proffesor-for-testing](https://github.com/proffesor-for-testing)
- **Source:** [proffesor-for-testing/agentic-qe](https://github.com/proffesor-for-testing/agentic-qe)
- **License:** MIT
- **Homepage:** https://agentic-qe.dev/

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-proffesor-for-testing-agentic-qe-flow-nexus-platform
- Seller: https://agentstack.voostack.com/s/proffesor-for-testing
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.