Cloud App Store

Manage the Flow Nexus application marketplace: discover, publish, deploy, and analyze applications and templates.

Quick Start

// Search for authentication apps const apps = await mcp__flow-nexus__app_search({ search: "authentication", category: "backend", featured: true });

// Deploy a template await mcp__flow-nexus__template_deploy({ template_name: "express-api-starter", deployment_name: "my-api", variables: { api_key: "your_api_key", database_url: "postgres://..." } });

// Publish your own app await mcp__flow-nexus__app_store_publish_app({ name: "My Auth Service", description: "JWT-based authentication microservice", category: "backend", source_code: sourceCode, tags: ["auth", "jwt", "express"] });

When to Use

• Discovering pre-built applications and templates

• Publishing applications to the marketplace

• Deploying templates for rapid project setup

• Analyzing app performance and user engagement

• Managing installed applications

• Tracking marketplace trends and statistics

Prerequisites

• Flow Nexus account with active session

• MCP server flow-nexus configured

• Publishing requires verified developer status

Core Concepts

App Categories

Category Description

Web APIs RESTful APIs, microservices, backend frameworks

Frontend React, Vue, Angular apps and component libraries

Full-Stack Complete applications with frontend and backend

CLI Tools Command-line utilities and productivity tools

Data Processing ETL pipelines, analytics, transformation tools

ML Models Pre-trained models, inference services

Blockchain Web3, smart contracts, DeFi protocols

Mobile React Native apps, mobile-first solutions

Template Types

• Starter Templates: Basic project scaffolding

• Feature Templates: Pre-built feature modules

• Full Applications: Complete, deployable apps

• Component Libraries: Reusable UI components

MCP Tools Reference

App Discovery

// Search apps mcp__flow-nexus__app_search({ search: "query string", // Search term category: "backend", // Category filter featured: true, // Featured apps only limit: 20 // Max results (1-100) }) // Returns: { apps: [{ id, name, description, category, rating }] }

// Get app details mcp__flow-nexus__app_get({ app_id: "app_id" }) // Returns: { id, name, description, version, author, downloads, rating }

// List installed apps mcp__flow-nexus__app_installed({ user_id: "user_id" }) // Returns: { installed_apps: [{ app_id, installed_at, version }] }

Template Management

// List templates mcp__flow-nexus__template_list({ category: "backend", featured: true, limit: 20 })

// Alternative: app store templates mcp__flow-nexus__app_store_list_templates({ category: "frontend", tags: ["react", "typescript"], limit: 20 })

// Get template details mcp__flow-nexus__template_get({ template_name: "express-api-starter" }) // Returns: { id, name, description, variables, requirements }

// Deploy template mcp__flow-nexus__template_deploy({ template_id: "template_id", // Or use template_name template_name: "express-api-starter", deployment_name: "my-project", variables: { api_key: "key", database_url: "postgres://..." }, env_vars: { NODE_ENV: "production" } }) // Returns: { deployment_id, url, status }

App Publishing

mcp__flow-nexus__app_store_publish_app({ name: "App Name", description: "Detailed description of the app", category: "backend", source_code: "// Your source code here", version: "1.0.0", tags: ["tag1", "tag2", "tag3"], metadata: { author: "Your Name", repository: "https://github.com/..." } }) // Returns: { app_id, status, review_pending }

App Management

// Update app mcp__flow-nexus__app_update({ app_id: "app_id", updates: { description: "Updated description", version: "1.1.0" } })

// Get analytics mcp__flow-nexus__app_analytics({ app_id: "app_id", timeframe: "30d" // 24h, 7d, 30d, 90d }) // Returns: { downloads, active_users, rating, revenue }

// Get market data mcp__flow-nexus__market_data() // Returns: { total_apps, total_downloads, trending, categories }

Usage Examples

Example 1: Finding and Deploying an API Template

// Search for API templates const templates = await mcp__flow-nexus__template_list({ category: "backend", featured: true });

// Find the Express starter const expressTemplate = templates.templates.find( t => t.name.includes("express") );

// Get template details const details = await mcp__flow-nexus__template_get({ template_id: expressTemplate.id });

console.log("Required variables:", details.variables);

// Deploy the template const deployment = await mcp__flow-nexus__template_deploy({ template_id: expressTemplate.id, deployment_name: "my-express-api", variables: { database_url: process.env.DATABASE_URL, jwt_secret: process.env.JWT_SECRET, port: "3000" }, env_vars: { NODE_ENV: "production" } });

console.log(Deployed at: ${deployment.url});

Example 2: Publishing a New Application

// Prepare your application const sourceCode = ` const express = require('express'); const jwt = require('jsonwebtoken');

const app = express(); app.use(express.json());

// JWT authentication middleware const authenticate = (req, res, next) => { const token = req.headers.authorization?.split(' ')[1]; if (!token) return res.status(401).json({ error: 'Unauthorized' });

try { req.user = jwt.verify(token, process.env.JWT_SECRET); next(); } catch { res.status(401).json({ error: 'Invalid token' }); } };

// Routes app.post('/login', (req, res) => { const { username, password } = req.body; // Authentication logic const token = jwt.sign({ username }, process.env.JWT_SECRET); res.json({ token }); });

app.get('/protected', authenticate, (req, res) => { res.json({ message: 'Protected data', user: req.user }); });

module.exports = app; `;

// Publish to app store const published = await mcp__flow-nexus__app_store_publish_app({ name: "JWT Auth Service", description: "A complete JWT authentication service with Express.js. Includes login, token verification, and protected route middleware.", category: "backend", source_code: sourceCode, version: "1.0.0", tags: ["authentication", "jwt", "express", "middleware", "security"], metadata: { author: "Your Name", license: "MIT", repository: "https://github.com/yourname/jwt-auth-service" } });

console.log(App published with ID: ${published.app_id});

Example 3: Analyzing App Performance

// Get your app's analytics const analytics = await mcp__flow-nexus__app_analytics({ app_id: "your_app_id", timeframe: "30d" });

console.log(` App Performance Report (Last 30 Days):

• Total Downloads: ${analytics.downloads}
• Active Users: ${analytics.active_users}
• Average Rating: ${analytics.rating}/5
• Revenue: ${analytics.revenue} rUv credits `);

// Get market trends const market = await mcp__flow-nexus__market_data();

console.log(` Market Overview:

• Total Apps: ${market.total_apps}
• Total Downloads: ${market.total_downloads}
• Trending Categories: ${market.trending.categories.join(', ')} `);

Example 4: Managing Installed Apps

// List installed apps const installed = await mcp__flow-nexus__app_installed({ user_id: "your_user_id" });

for (const app of installed.installed_apps) { // Get details for each installed app const details = await mcp__flow-nexus__app_get({ app_id: app.app_id });

console.log(${details.name} v${app.version} - Installed: ${app.installed_at}); }

Execution Checklist

For App Discovery

• Search with relevant keywords and filters

• Review app details and documentation

• Check ratings and reviews

• Verify category and template requirements

• Deploy with appropriate configuration

For App Publishing

• Prepare clean, well-documented source code

• Write comprehensive description

• Add relevant tags for discoverability

• Set appropriate version number

• Include metadata (author, license, repository)

• Submit for review

Best Practices

• Clear Descriptions: Write detailed, helpful app descriptions

• Proper Tagging: Use relevant tags for discoverability

• Version Management: Follow semantic versioning

• Documentation: Include README and usage examples

• Security Scanning: Ensure code passes security checks

• Regular Updates: Keep apps updated and maintained

Error Handling

Error Cause Solution

app_not_found

Invalid app_id Use app_search to find valid IDs

publish_failed

Invalid source code or metadata Verify all required fields

template_deploy_failed

Missing required variables Check template requirements

unauthorized

Not logged in or insufficient permissions Authenticate first

duplicate_app_name

App name already exists Choose unique name

Metrics & Success Criteria

• App Downloads: Track total and daily downloads

• User Rating: Target >4.0/5 average rating

• Active Users: Monitor engagement over time

• Revenue: Track rUv credit earnings

• Deployment Success: >95% successful deployments

Integration Points

With Sandboxes

// Deploy template to sandbox for testing const sandbox = await mcp__flow-nexus__sandbox_create({ template: "node" });

await mcp__flow-nexus__template_deploy({ template_name: "express-api-starter", variables: { sandbox_id: sandbox.sandbox_id } });

With Payments

// Track app revenue const balance = await mcp__flow-nexus__ruv_balance({ user_id: "publisher_id" });

// Revenue from published apps appears in balance

Related Skills

• cloud-sandbox - Execution environments

• cloud-workflow - Workflow automation

• cloud-payments - Credit management

References

• Flow Nexus App Store

• Publishing Guidelines

Version History

• 1.0.0 (2026-01-02): Initial release - converted from flow-nexus-app-store agent