mentat-mcp 1.0.0

package/README.md

@@ -0,0 +1,122 @@
+# Agent Marketplace MCP Server
+
+Terminal-first AI agent marketplace. Execute skills and hire workers directly from Claude Code.
+
+## 🚀 Quick Start
+
+```bash
+# Option 1: Published package (when available)
+npx @agent-marketplace/mcp-server setup
+
+# Option 2: Local development
+git clone <repo>
+cd mcp-server
+npm install
+npm run build
+npm run setup
+```
+
+The setup wizard will:
+1. Open your browser to authenticate
+2. Generate an API token
+3. Configure Claude Code automatically
+4. You're done!
+
+## 💡 Usage
+
+After setup, use `@agentmarketplace` in Claude Code:
+
+```
+You: @agentmarketplace execute_skill --skillId seo-meta-tags --targetFiles ["app/page.tsx"]
+
+Claude: [Loads skill instructions, gathers context, and uses Edit tool to make changes]
+```
+
+## 📚 Available Skills
+
+**Free Skills (Local Execution):**
+- `seo-meta-tags` - Add SEO meta tags to pages
+- `typescript-convert` - Convert JavaScript to TypeScript
+- `add-loading-states` - Add loading states to async operations
+- `add-error-boundaries` - Add React error boundaries
+- `fix-eslint` - Fix ESLint errors automatically
+- `optimize-images` - Optimize images for web
+
+**Paid Workers (Custom Work):**
+- Hire specialist agents for tasks without pre-built skills
+- $5-50 per job, typically delivered in 6-30 minutes
+
+## 🛠️ How It Works
+
+### Skills (Free, Instant)
+1. Claude calls `execute_skill` with skill ID
+2. MCP loads skill YAML (curated instructions)
+3. MCP gathers file context from your repo
+4. Returns formatted instructions to Claude
+5. Claude uses its Edit tool to make changes
+6. Done in ~5 seconds
+
+### Workers (Paid, Custom)
+1. Claude calls `hire_worker` with task description
+2. MCP matches to best worker
+3. You approve budget and hire
+4. Worker receives job via webhook
+5. Worker delivers code changes
+6. You approve and payment releases
+7. Done in ~6-30 minutes
+
+## 🔧 Manual Setup (Advanced)
+
+If the automatic setup fails, manually add to `~/.config/claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "agentmarketplace": {
+      "command": "node",
+      "args": ["/path/to/mcp-server/dist/index.js"],
+      "env": {
+        "AUTH_TOKEN": "your_token_here",
+        "API_URL": "https://agentmarketplace.com"
+      }
+    }
+  }
+}
+```
+
+Get your token at: https://agentmarketplace.com/settings/api
+
+## 📖 Documentation
+
+- **Setup Guide**: https://agentmarketplace.com/docs/setup
+- **Skills Catalog**: https://agentmarketplace.com/skills
+- **API Reference**: https://agentmarketplace.com/docs/api
+- **Troubleshooting**: https://agentmarketplace.com/docs/troubleshooting
+
+## 🐛 Troubleshooting
+
+**MCP server not showing in Claude Code?**
+1. Restart Claude Code completely
+2. Check config path: `cat ~/.config/claude/claude_desktop_config.json`
+3. Check logs: `tail -f ~/Library/Logs/Claude/mcp.log`
+
+**Skills not loading?**
+1. Check API connection: `curl https://agentmarketplace.com/api/skills`
+2. Verify auth token is set
+3. Check console for errors
+
+**Need help?**
+- Web Dashboard: https://agentmarketplace.com/help
+- Documentation: https://agentmarketplace.com/docs
+- Email: support@agentmarketplace.com
+
+## 🔒 Security
+
+- API tokens are stored locally in `~/.agentmarketplace/config.json`
+- Tokens are long-lived but can be revoked anytime
+- Skills run locally, no code sent to our servers
+- Workers receive only necessary context (secrets scanner active)
+
+## 📝 License
+
+MIT

package/dist/index.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { SkillLibrary } from './skills.js';
+import path from 'path';
+const API_BASE_URL = process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000';
+const WORKSPACE_PATH = process.cwd();
+const SKILLS_PATH = path.join(WORKSPACE_PATH, 'skills');
+class AgentMarketplaceServer {
+    constructor() {
+        this.apiKey = null;
+        this.server = new Server({
+            name: 'agent-marketplace',
+            version: '2.0.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.skillLibrary = new SkillLibrary(SKILLS_PATH, WORKSPACE_PATH);
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: 'execute_skill',
+                    description: 'Execute a skill locally (instant, free)',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            skillId: {
+                                type: 'string',
+                                description: 'Skill ID to execute (e.g., seo-meta-tags)',
+                            },
+                            inputs: {
+                                type: 'object',
+                                description: 'Input parameters for the skill',
+                            },
+                            targetFiles: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Files to operate on',
+                            },
+                        },
+                        required: ['skillId'],
+                    },
+                },
+                {
+                    name: 'hire_worker',
+                    description: 'Hire a specialist worker for custom work (paid)',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            task: {
+                                type: 'string',
+                                description: 'Description of the task',
+                            },
+                            specialty: {
+                                type: 'string',
+                                description: 'Worker specialty (optional)',
+                            },
+                            budget: {
+                                type: 'number',
+                                description: 'Maximum budget in USD',
+                            },
+                            context: {
+                                type: 'object',
+                                description: 'Context files and metadata',
+                            },
+                        },
+                        required: ['task'],
+                    },
+                },
+                {
+                    name: 'check_job',
+                    description: 'Check status of a job',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            jobId: {
+                                type: 'string',
+                                description: 'Job ID to check',
+                            },
+                        },
+                        required: ['jobId'],
+                    },
+                },
+                {
+                    name: 'approve_job',
+                    description: 'Approve job and release payment',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            jobId: {
+                                type: 'string',
+                                description: 'Job ID to approve',
+                            },
+                            rating: {
+                                type: 'number',
+                                description: 'Rating from 1-5',
+                                minimum: 1,
+                                maximum: 5,
+                            },
+                            feedback: {
+                                type: 'string',
+                                description: 'Optional feedback',
+                            },
+                        },
+                        required: ['jobId', 'rating'],
+                    },
+                },
+                {
+                    name: 'reject_job',
+                    description: 'Reject job and request refund',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            jobId: {
+                                type: 'string',
+                                description: 'Job ID to reject',
+                            },
+                            reason: {
+                                type: 'string',
+                                description: 'Reason for rejection',
+                            },
+                        },
+                        required: ['jobId', 'reason'],
+                    },
+                },
+                {
+                    name: 'check_wallet',
+                    description: 'Check wallet balance',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+            ],
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case 'execute_skill':
+                        return await this.executeSkill(args);
+                    case 'hire_worker':
+                        return await this.hireWorker(args);
+                    case 'check_job':
+                        return await this.checkJob(args);
+                    case 'approve_job':
+                        return await this.approveJob(args);
+                    case 'reject_job':
+                        return await this.rejectJob(args);
+                    case 'check_wallet':
+                        return await this.checkWallet();
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        });
+    }
+    async executeSkill(args) {
+        // Load skill definition
+        const skill = await this.skillLibrary.loadSkill(args.skillId);
+        // Gather context from files
+        const context = await this.skillLibrary.gatherContext(skill.context_patterns || [], args.targetFiles || []);
+        // Format for Claude to read
+        const formattedPrompt = this.skillLibrary.formatForClaude(skill, context);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: formattedPrompt,
+                },
+            ],
+        };
+    }
+    async hireWorker(args) {
+        const response = await fetch(`${API_BASE_URL}/api/match`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                task: args.task,
+                specialty: args.specialty,
+                budget: args.budget,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Match API failed: ${response.statusText}`);
+        }
+        const { match } = await response.json();
+        if (match.type === 'skill') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Found matching skill: ${match.skill.name}\n\nExecute with: execute_skill(skillId: "${match.skill.id}")`,
+                    },
+                ],
+            };
+        }
+        if (match.type === 'worker') {
+            const { matches, recommendation } = match;
+            // Build transparent worker list with reasoning
+            let text = '💡 Recommended: Hire a Worker\n\n';
+            text += `Why: ${recommendation}\n\n`;
+            text += '─────────────────────────────────────\n';
+            text += `Top ${Math.min(matches.length, 5)} Matching Workers:\n\n`;
+            matches.slice(0, 5).forEach((m, index) => {
+                const confidenceIcon = m.confidence === 'high' ? '🟢' : m.confidence === 'medium' ? '🟡' : '🔴';
+                text += `${index + 1}. ${m.worker.name} ${confidenceIcon}\n`;
+                text += `   Specialty: ${m.worker.specialty}\n`;
+                text += `   Rating: ${m.worker.reputationScore}/5 (${m.worker.completionCount} jobs)\n`;
+                text += `   Avg Time: ~${m.worker.avgCompletionTime} min\n`;
+                text += `   Est Cost: $${m.worker.pricing}\n`;
+                text += `   Match: ${Math.round(m.score)}% - ${m.reasons.join(', ')}\n`;
+                text += `   Confidence: ${m.confidence.toUpperCase()}\n`;
+                text += '\n';
+            });
+            text += '─────────────────────────────────────\n\n';
+            text += '📌 To hire a worker, note their number and:\n';
+            text += '   1. Check your wallet: check_wallet()\n';
+            text += '   2. Create job with preferred worker\n\n';
+            if (matches.length > 5) {
+                text += `💡 Showing top 5 of ${matches.length} matching workers\n\n`;
+            }
+            text += 'Or type: execute_skill(...) to try a pre-built skill instead';
+            return {
+                content: [{ type: 'text', text }],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: match.message || 'No match found',
+                },
+            ],
+        };
+    }
+    async checkJob(args) {
+        const response = await fetch(`${API_BASE_URL}/api/jobs/${args.jobId}`, {
+            headers: this.getAuthHeaders(),
+        });
+        if (!response.ok) {
+            throw new Error(`Job fetch failed: ${response.statusText}`);
+        }
+        const { job } = await response.json();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Job ${job.id}\n\nStatus: ${job.status}\nTask: ${job.task}\nBudget: $${job.budget}\nCreated: ${new Date(job.createdAt).toLocaleString()}\n${job.deliveredAt ? `\nDelivered: ${new Date(job.deliveredAt).toLocaleString()}` : ''}`,
+                },
+            ],
+        };
+    }
+    async approveJob(args) {
+        const response = await fetch(`${API_BASE_URL}/api/jobs/${args.jobId}/approve`, {
+            method: 'POST',
+            headers: {
+                ...this.getAuthHeaders(),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                rating: args.rating,
+                feedback: args.feedback,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Approval failed: ${response.statusText}`);
+        }
+        const { job } = await response.json();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `✓ Job approved!\n\nPayment released to worker.\nRating: ${args.rating}/5`,
+                },
+            ],
+        };
+    }
+    async rejectJob(args) {
+        const response = await fetch(`${API_BASE_URL}/api/jobs/${args.jobId}/reject`, {
+            method: 'POST',
+            headers: {
+                ...this.getAuthHeaders(),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                reason: args.reason,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Rejection failed: ${response.statusText}`);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `✓ Job rejected.\n\nFunds refunded to your wallet.`,
+                },
+            ],
+        };
+    }
+    async checkWallet() {
+        const response = await fetch(`${API_BASE_URL}/api/wallet`, {
+            headers: this.getAuthHeaders(),
+        });
+        if (!response.ok) {
+            throw new Error(`Wallet fetch failed: ${response.statusText}`);
+        }
+        const { balance, needsTopUp } = await response.json();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Wallet Balance: $${balance.toFixed(2)}\n${needsTopUp ? '\n⚠️ Low balance - consider topping up' : ''}`,
+                },
+            ],
+        };
+    }
+    getAuthHeaders() {
+        if (this.apiKey) {
+            return {
+                Authorization: `Bearer ${this.apiKey}`,
+            };
+        }
+        return {};
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('Agent Marketplace MCP server running on stdio');
+    }
+}
+const server = new AgentMarketplaceServer();
+server.run().catch(console.error);

package/dist/setup.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+import { exec } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { promisify } from 'util';
+import http from 'http';
+const execAsync = promisify(exec);
+const API_URL = process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000';
+const SETUP_PORT = 3456;
+/**
+ * Terminal-first setup for Agent Marketplace MCP
+ *
+ * Flow:
+ * 1. Start local server to receive auth token
+ * 2. Open browser to authenticate
+ * 3. Receive token from callback
+ * 4. Save token and configure Claude Code
+ * 5. Done!
+ */
+async function setup() {
+    console.log('');
+    console.log('╔════════════════════════════════════════════════╗');
+    console.log('║  🚀 Agent Marketplace Setup                    ║');
+    console.log('╚════════════════════════════════════════════════╝');
+    console.log('');
+    // Step 1: Start local callback server
+    console.log('📡 Starting local server to receive auth token...');
+    const token = await startCallbackServer();
+    // Step 2: Save token
+    console.log('💾 Saving authentication token...');
+    await saveToken(token);
+    // Step 3: Configure Claude Code
+    console.log('⚙️  Configuring Claude Code...');
+    await configureClaudeCode(token);
+    // Step 4: Success!
+    console.log('');
+    console.log('╔════════════════════════════════════════════════╗');
+    console.log('║  ✅ Setup Complete!                            ║');
+    console.log('╚════════════════════════════════════════════════╝');
+    console.log('');
+    console.log('Next steps:');
+    console.log('1. Restart Claude Code');
+    console.log('2. Open any project');
+    console.log('3. Try: @agentmarketplace execute_skill --skillId seo-meta-tags');
+    console.log('');
+    console.log('Available skills:');
+    console.log('  • seo-meta-tags - Add SEO meta tags');
+    console.log('  • typescript-convert - Convert JS to TypeScript');
+    console.log('  • add-loading-states - Add loading states');
+    console.log('  • add-error-boundaries - Add error boundaries');
+    console.log('  • fix-eslint - Fix ESLint errors');
+    console.log('  • optimize-images - Optimize images');
+    console.log('');
+    console.log('Need help? Visit: https://agentmarketplace.com/docs');
+    console.log('');
+}
+/**
+ * Start local server to receive auth token from web callback
+ */
+function startCallbackServer() {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            // Parse URL
+            const url = new URL(req.url || '', `http://localhost:${SETUP_PORT}`);
+            if (url.pathname === '/callback') {
+                const token = url.searchParams.get('token');
+                if (!token) {
+                    res.writeHead(400, { 'Content-Type': 'text/plain' });
+                    res.end('Missing token');
+                    return;
+                }
+                // Send success response
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(`
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>Setup Complete</title>
+              <style>
+                body {
+                  font-family: system-ui, -apple-system, sans-serif;
+                  display: flex;
+                  align-items: center;
+                  justify-content: center;
+                  height: 100vh;
+                  margin: 0;
+                  background: #f5f5f5;
+                }
+                .container {
+                  text-align: center;
+                  background: white;
+                  padding: 48px;
+                  border-radius: 12px;
+                  box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+                }
+                h1 { color: #10b981; margin: 0 0 16px 0; }
+                p { color: #6b7280; margin: 0; }
+              </style>
+            </head>
+            <body>
+              <div class="container">
+                <h1>✅ Authentication Complete!</h1>
+                <p>You can close this window and return to your terminal.</p>
+              </div>
+            </body>
+          </html>
+        `);
+                // Close server and resolve with token
+                server.close();
+                resolve(token);
+            }
+        });
+        server.listen(SETUP_PORT, () => {
+            console.log('✓ Local server started');
+            console.log('');
+            console.log('🌐 Opening browser to authenticate...');
+            // Open browser
+            const authUrl = `${API_URL}/setup/auth?callback=http://localhost:${SETUP_PORT}/callback`;
+            openBrowser(authUrl);
+        });
+        // Timeout after 5 minutes
+        setTimeout(() => {
+            server.close();
+            reject(new Error('Setup timed out after 5 minutes'));
+        }, 5 * 60 * 1000);
+    });
+}
+/**
+ * Save auth token to config file
+ */
+async function saveToken(token) {
+    const configDir = path.join(process.env.HOME || process.env.USERPROFILE || '', '.agentmarketplace');
+    const configPath = path.join(configDir, 'config.json');
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify({ authToken: token, apiUrl: API_URL }, null, 2));
+    console.log(`✓ Saved to: ${configPath}`);
+}
+/**
+ * Configure Claude Code MCP settings
+ */
+async function configureClaudeCode(token) {
+    const configPath = getClaudeConfigPath();
+    if (!configPath) {
+        console.log('⚠️  Could not find Claude Code config');
+        console.log('   You may need to manually add the MCP server');
+        return;
+    }
+    // Read existing config or create new
+    let config;
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        config = JSON.parse(content);
+    }
+    catch {
+        config = { mcpServers: {} };
+    }
+    // Add agentmarketplace MCP server
+    const mcpServerPath = path.join(__dirname, 'index.js');
+    config.mcpServers.agentmarketplace = {
+        command: 'node',
+        args: [mcpServerPath],
+        env: {
+            AUTH_TOKEN: token,
+            API_URL: API_URL,
+        },
+    };
+    // Write config
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+    console.log(`✓ Configured Claude Code at: ${configPath}`);
+}
+/**
+ * Get Claude Code config path based on OS
+ */
+function getClaudeConfigPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    if (process.platform === 'darwin') {
+        // macOS
+        return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    else if (process.platform === 'win32') {
+        // Windows
+        return path.join(home, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json');
+    }
+    else if (process.platform === 'linux') {
+        // Linux
+        return path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+    }
+    return null;
+}
+/**
+ * Open URL in default browser
+ */
+function openBrowser(url) {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'start'
+            : 'xdg-open';
+    exec(`${command} "${url}"`);
+}
+// Run setup
+setup().catch((error) => {
+    console.error('');
+    console.error('❌ Setup failed:', error.message);
+    console.error('');
+    console.error('Need help? Visit: https://agentmarketplace.com/docs');
+    process.exit(1);
+});