@vibesharingapp/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,169 @@
+# VibeSharing MCP Server
+
+**The missing link between your AI coding assistant and your team.**
+
+Build prototypes with Claude Code, Cursor, or any AI tool—then instantly share them with your team for feedback. No context switching. No copy-pasting URLs. Just ship and collaborate.
+
+## The Problem
+
+You're building fast with AI. Prototypes are flying. But then:
+
+- You deploy to Vercel and... forget to tell anyone
+- Your teammate asks "where's that dashboard thing you made?"
+- Feedback lives in Slack threads that disappear
+- Next AI session? All that context is gone
+
+**Your AI helps you build. But it can't help you collaborate.**
+
+Until now.
+
+## The Solution
+
+VibeSharing's MCP server connects Claude Code directly to your team's prototype hub. Every prototype you build becomes instantly shareable, trackable, and open for feedback.
+
+```
+You: "Register this on VibeSharing, it's deployed at my-app.vercel.app"
+
+Claude: Done! Your team can now view and leave feedback at:
+        vibesharing.app/dashboard/projects/abc123
+```
+
+That's it. Your prototype is live on VibeSharing. Your team gets notified. Feedback flows back to you.
+
+## What You Can Do
+
+### Ship prototypes without leaving your terminal
+```
+"Deploy this to Vercel and register it on VibeSharing"
+```
+Claude handles the deployment AND registers it with your team—in one conversation.
+
+### Check what your team thinks
+```
+"What feedback did I get on the checkout flow prototype?"
+```
+See comments, suggestions, and resolved issues without opening a browser.
+
+### Keep context alive across sessions
+```
+"Sync my CLAUDE.md to VibeSharing"
+```
+Your project context persists on VibeSharing, so any team member (or AI session) can pick up where you left off.
+
+### See all your work in one place
+```
+"List my prototypes"
+```
+Every prototype you've registered, with links and recent activity.
+
+## Quick Start
+
+### 1. Install
+
+```bash
+npm install -g @vibesharingapp/mcp-server
+```
+
+### 2. Get Your Token
+
+Sign up at [vibesharing.app](https://vibesharing.app) and grab your deploy token from Account Settings.
+
+### 3. Configure Claude Code
+
+Add to your Claude Code settings:
+
+```json
+{
+  "mcpServers": {
+    "vibesharing": {
+      "command": "vibesharing-mcp",
+      "env": {
+        "VIBESHARING_TOKEN": "vs_your_token_here"
+      }
+    }
+  }
+}
+```
+
+### 4. Start Building
+
+That's it. Ask Claude to register prototypes, check feedback, or sync context. It just works.
+
+## Why This Matters
+
+### For Solo Builders
+Stop losing track of what you've built. Every prototype is catalogued, shareable, and ready for feedback when you need it.
+
+### For Teams
+Finally, visibility into what everyone's shipping. No more "hey, can you send me that link again?" Feedback is structured, threaded, and actionable.
+
+### For Design Leaders
+See the full picture of your team's prototyping velocity. Guide feedback with custom topics. Keep stakeholders in the loop without endless meetings.
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `register_prototype` | Register a deployed prototype with name, description, and URL |
+| `list_prototypes` | List all prototypes in your organization |
+| `get_feedback` | Get feedback and comments for any prototype |
+| `sync_context` | Push CLAUDE.md or project notes to VibeSharing |
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `VIBESHARING_TOKEN` | Yes | Your deploy token from VibeSharing |
+| `VIBESHARING_URL` | No | Custom API URL (defaults to https://vibesharing.app) |
+
+## Examples
+
+### Register after deploying
+```
+You: "I just deployed to https://checkout-v2.vercel.app - register it on VibeSharing
+      as 'Checkout Flow v2' and mention it simplifies the payment step"
+
+Claude: Registered! Your team can view and leave feedback at:
+        https://vibesharing.app/dashboard/projects/xyz789
+```
+
+### Get feedback before your next session
+```
+You: "Before I continue on the dashboard, what feedback came in?"
+
+Claude: 3 new comments on Dashboard Redesign:
+        - Sarah: "Love the new nav, but can we make the search more prominent?"
+        - Mike: "The loading states feel snappy now"
+        - Alex: "Can we add keyboard shortcuts?" [Resolved]
+```
+
+### Keep your AI context in sync
+```
+You: "Sync my CLAUDE.md to the Dashboard project on VibeSharing"
+
+Claude: Context synced! Your team can now see your project notes at:
+        https://vibesharing.app/dashboard/projects/abc123
+```
+
+## Built for the AI-Native Workflow
+
+VibeSharing isn't just another tool to check. It's infrastructure for teams building with AI:
+
+- **CLAUDE.md sync** keeps context alive across sessions and team members
+- **Guided feedback topics** help stakeholders give useful input
+- **Email notifications** when prototypes update or get feedback
+- **Works with any deploy target** - Vercel, Netlify, Replit, Lovable, v0, or paste any URL
+
+## Learn More
+
+- [VibeSharing](https://vibesharing.app) - Sign up free
+- [Documentation](https://vibesharing.app/get-started) - Full setup guide
+- [GitHub](https://github.com/erova/vibesharing) - Source code
+
+---
+
+**Stop building in isolation. Start shipping with your team.**
+
+```bash
+npm install -g @vibesharingapp/mcp-server
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+// VibeSharing API client
+class VibesharingClient {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.token = token;
+    }
+    async request(path, options = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.token}`,
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: response.statusText }));
+            throw new Error(error.error || `API error: ${response.status}`);
+        }
+        return response.json();
+    }
+    async registerPrototype(params) {
+        return this.request("/api/prototypes", {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    async listPrototypes() {
+        return this.request("/api/prototypes");
+    }
+    async getPrototype(id) {
+        return this.request(`/api/prototypes/${id}`);
+    }
+    async getFeedback(projectId) {
+        return this.request(`/api/feedback?projectId=${projectId}`);
+    }
+    async syncContext(projectId, content) {
+        return this.request("/api/context", {
+            method: "POST",
+            body: JSON.stringify({ projectId, content }),
+        });
+    }
+}
+// Get configuration from environment
+const VIBESHARING_URL = process.env.VIBESHARING_URL || "https://vibesharing.app";
+const VIBESHARING_TOKEN = process.env.VIBESHARING_TOKEN;
+if (!VIBESHARING_TOKEN) {
+    console.error("Error: VIBESHARING_TOKEN environment variable is required");
+    console.error("Get your deploy token from VibeSharing → Account Settings");
+    process.exit(1);
+}
+const client = new VibesharingClient(VIBESHARING_URL, VIBESHARING_TOKEN);
+// Create MCP server
+const server = new index_js_1.Server({
+    name: "vibesharing",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+// Define available tools
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "register_prototype",
+                description: "Register a new prototype on VibeSharing. Use this after deploying a prototype to Vercel, Netlify, or any hosting service. Returns the VibeSharing URL where the team can view and leave feedback.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Name of the prototype (e.g., 'Dashboard Redesign v2')",
+                        },
+                        description: {
+                            type: "string",
+                            description: "Brief description of what this prototype demonstrates",
+                        },
+                        external_url: {
+                            type: "string",
+                            description: "URL where the prototype is deployed (e.g., https://my-app.vercel.app)",
+                        },
+                        parent_project_id: {
+                            type: "string",
+                            description: "Optional: ID of parent project if this is a version/iteration",
+                        },
+                    },
+                    required: ["name"],
+                },
+            },
+            {
+                name: "list_prototypes",
+                description: "List all prototypes in your VibeSharing organization. Shows name, URL, and recent activity.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "get_feedback",
+                description: "Get feedback and comments for a specific prototype. Use this to see what the team thinks about a prototype.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        project_id: {
+                            type: "string",
+                            description: "The VibeSharing project/prototype ID",
+                        },
+                    },
+                    required: ["project_id"],
+                },
+            },
+            {
+                name: "sync_context",
+                description: "Sync your CLAUDE.md or project context to VibeSharing. This helps maintain context across AI sessions and team members.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        project_id: {
+                            type: "string",
+                            description: "The VibeSharing project/prototype ID to sync context to",
+                        },
+                        content: {
+                            type: "string",
+                            description: "The context content (typically contents of CLAUDE.md)",
+                        },
+                    },
+                    required: ["project_id", "content"],
+                },
+            },
+        ],
+    };
+});
+// Handle tool calls
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "register_prototype": {
+                const params = args;
+                const result = await client.registerPrototype(params);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Prototype registered successfully!\n\nName: ${result.project?.name || params.name}\nVibeSharing URL: ${VIBESHARING_URL}/dashboard/projects/${result.project?.id}\n${params.external_url ? `Live URL: ${params.external_url}` : ""}\n\nYour team can now view and leave feedback on this prototype.`,
+                        },
+                    ],
+                };
+            }
+            case "list_prototypes": {
+                const result = await client.listPrototypes();
+                const prototypes = result.prototypes || [];
+                if (prototypes.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "No prototypes found. Use register_prototype to add your first one!",
+                            },
+                        ],
+                    };
+                }
+                const list = prototypes
+                    .map((p) => `- ${p.name}\n  ID: ${p.id}\n  ${p.external_url ? `URL: ${p.external_url}\n  ` : ""}Updated: ${new Date(p.updated_at).toLocaleDateString()}`)
+                    .join("\n\n");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Found ${prototypes.length} prototype(s):\n\n${list}`,
+                        },
+                    ],
+                };
+            }
+            case "get_feedback": {
+                const { project_id } = args;
+                const result = await client.getFeedback(project_id);
+                const feedback = result.feedback || [];
+                if (feedback.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "No feedback yet for this prototype. Share it with your team to get their thoughts!",
+                            },
+                        ],
+                    };
+                }
+                const feedbackList = feedback
+                    .map((f) => {
+                    const status = f.resolved_at ? " [Resolved]" : "";
+                    const replies = f.replies && f.replies.length > 0
+                        ? `\n  Replies: ${f.replies.length}`
+                        : "";
+                    return `- ${f.user_name}${status}: "${f.content}"\n  ${new Date(f.created_at).toLocaleDateString()}${replies}`;
+                })
+                    .join("\n\n");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Feedback (${feedback.length} items):\n\n${feedbackList}`,
+                        },
+                    ],
+                };
+            }
+            case "sync_context": {
+                const { project_id, content } = args;
+                await client.syncContext(project_id, content);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Context synced successfully to VibeSharing!\n\nProject ID: ${project_id}\nContent length: ${content.length} characters\n\nThis context will be available to team members viewing the prototype.`,
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unknown tool: ${name}`,
+                        },
+                    ],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// List available resources (prototypes as resources)
+server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+    try {
+        const result = await client.listPrototypes();
+        const prototypes = result.prototypes || [];
+        return {
+            resources: prototypes.map((p) => ({
+                uri: `vibesharing://prototype/${p.id}`,
+                name: p.name,
+                description: p.description || `Prototype: ${p.name}`,
+                mimeType: "application/json",
+            })),
+        };
+    }
+    catch {
+        return { resources: [] };
+    }
+});
+// Read a specific resource
+server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const match = uri.match(/^vibesharing:\/\/prototype\/(.+)$/);
+    if (!match) {
+        throw new Error(`Invalid resource URI: ${uri}`);
+    }
+    const projectId = match[1];
+    const [prototype, feedbackResult] = await Promise.all([
+        client.getPrototype(projectId),
+        client.getFeedback(projectId),
+    ]);
+    return {
+        contents: [
+            {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify({
+                    prototype: prototype.project,
+                    feedback: feedbackResult.feedback,
+                }, null, 2),
+            },
+        ],
+    };
+});
+// Start the server
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("VibeSharing MCP server running");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@vibesharingapp/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for VibeSharing - register prototypes and get feedback directly from Claude Code",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "vibesharing-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "claude-code",
+    "vibesharing",
+    "prototypes",
+    "feedback",
+    "collaboration",
+    "ai",
+    "cursor",
+    "vibe-coding"
+  ],
+  "author": "VibeSharing <hello@vibesharing.app>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/erova/vibesharing.git",
+    "directory": "mcp-server"
+  },
+  "bugs": {
+    "url": "https://github.com/erova/vibesharing/issues"
+  },
+  "homepage": "https://vibesharing.app",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}