vibekit-mcp 0.2.0 → 0.3.0

package/README.md

@@ -1,68 +1,101 @@
 # vibekit-mcp
 
-MCP (Model Context Protocol) server for [VibeKit](https://vibekit.bot) — use AI coding tasks as native tools in Claude Desktop, Cursor, and other MCP-compatible clients.
+MCP server for [VibeKit](https://vibekit.bot) — manage AI-powered apps as native tools in Claude Desktop, Cursor, Windsurf, and any MCP-compatible client.
 
-## Installation
+## Setup
 
-```bash
-npm install -g vibekit-mcp
-```
+### Claude Desktop
 
-## Setup
+Add to your `claude_desktop_config.json`:
 
-1. Get a VibeKit API key:
-   - Open [@the_vibe_kit_bot](https://t.me/the_vibe_kit_bot) in Telegram
-   - Send `/apikey` to generate your key
+```json
+{
+  "mcpServers": {
+    "vibekit": {
+      "command": "npx",
+      "args": ["-y", "vibekit-mcp"],
+      "env": {
+        "VIBEKIT_API_KEY": "vk_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Cursor
 
-2. Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+Add to `.cursor/mcp.json` in your project:
 
 ```json
 {
   "mcpServers": {
     "vibekit": {
-      "command": "vibekit-mcp",
+      "command": "npx",
+      "args": ["-y", "vibekit-mcp"],
       "env": {
-        "VIBEKIT_API_KEY": "vk_your_api_key_here"
+        "VIBEKIT_API_KEY": "vk_your_key_here"
       }
     }
   }
 }
 ```
 
-3. Restart Claude Desktop
+Get your API key at [app.vibekit.bot/settings](https://app.vibekit.bot/settings).
 
 ## Available Tools
 
-| Tool | Description |
-|------|-------------|
-| `vibekit_submit_task` | Submit a coding task. AI writes code, commits to GitHub, deploys to Vercel. |
-| `vibekit_get_task` | Get status/result of a task |
-| `vibekit_list_tasks` | List recent tasks |
-| `vibekit_wait_for_task` | Wait for a task to complete (polls until done) |
-| `vibekit_create_schedule` | Create a recurring scheduled task |
-| `vibekit_list_schedules` | List all scheduled tasks |
-| `vibekit_delete_schedule` | Delete a scheduled task |
-| `vibekit_account` | Get account info (plan, credits, usage) |
+### Apps
+- `vibekit_list_apps` — List all your hosted apps
+- `vibekit_app_info` — Get app details
+- `vibekit_start` / `vibekit_stop` / `vibekit_restart` — Container control
 
-## Example Usage
+### AI Agent
+- `vibekit_chat` — Send a message to your app's AI agent
+- `vibekit_agent_status` — Agent status and model info
 
-Once configured, you can ask Claude things like:
+### Deploy
+- `vibekit_deploy` — Trigger redeploy
+- `vibekit_deploys` — Deploy history
+- `vibekit_rollback` — Rollback to previous deploy
 
-- "Use VibeKit to build me a landing page for my startup"
-- "Submit a task to VibeKit: Add a contact form to my website"
-- "Check my VibeKit account balance"
-- "Create a weekly schedule to improve SEO on my repo"
+### Logs & Files
+- `vibekit_logs` — View app logs
+- `vibekit_files` — Browse workspace files
 
-## Environment Variables
+### Environment
+- `vibekit_env_list` / `vibekit_env_set` / `vibekit_env_delete` — Manage env vars
 
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `VIBEKIT_API_KEY` | Your VibeKit API key (required) | — |
-| `VIBEKIT_API_URL` | API base URL | `https://vibekit.bot/api/v1` |
+### Database
+- `vibekit_db_status` — Database stats
+- `vibekit_db_schema` — Tables, columns, types
+- `vibekit_db_query` — Run read-only SQL
+- `vibekit_db_table` — Browse table data
+
+### Domain & QA
+- `vibekit_set_domain` — Set custom domain
+- `vibekit_qa` — Run QA audit
+
+### Tasks
+- `vibekit_submit_task` — Submit a headless coding task
+- `vibekit_task_status` — Check task status
+- `vibekit_account` — Plan, balance, usage
+
+## Example Usage
+
+Once connected, you can say things like:
+
+- "List my VibeKit apps"
+- "Show me the logs for my surf app"
+- "Tell my agent to add a dark mode toggle"
+- "Run a SQL query on my database"
+- "Deploy my app"
 
 ## Links
 
-- [VibeKit Website](https://vibekit.bot)
-- [API Documentation](https://vibekit.bot/SKILL.md)
-- [Get API Key](https://t.me/the_vibe_kit_bot)
-- [GitHub](https://github.com/609NFT/vibekit)
+- Website: https://vibekit.bot
+- Dashboard: https://app.vibekit.bot
+- CLI: https://www.npmjs.com/package/vibekit-cli
+
+## License
+
+MIT

package/dist/index.js

@@ -6,349 +6,381 @@ const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const API_BASE = process.env.VIBEKIT_API_URL || "https://vibekit.bot/api/v1";
 const API_KEY = process.env.VIBEKIT_API_KEY || "";
-const SKILLS_REGISTRY = "https://raw.githubusercontent.com/vibekit-apps/skills-registry/main";
-// Skills cache (TTL: 5 minutes)
-let skillsCache = null;
-const CACHE_TTL = 5 * 60 * 1000;
 if (!API_KEY) {
-    console.error("Error: VIBEKIT_API_KEY environment variable is required");
-    console.error("Get one at https://t.me/the_vibe_kit_bot with /apikey command");
+    console.error("VIBEKIT_API_KEY is required. Get one at https://app.vibekit.bot/settings");
     process.exit(1);
 }
-// API helper
-async function apiRequest(method, path, body) {
+// ── API Helper ──────────────────────────────────────────────────────────────
+async function api(method, path, body) {
     try {
         const res = await fetch(`${API_BASE}${path}`, {
             method,
-            headers: {
-                "Authorization": `Bearer ${API_KEY}`,
-                "Content-Type": "application/json",
-            },
+            headers: { Authorization: `Bearer ${API_KEY}`, "Content-Type": "application/json" },
             body: body ? JSON.stringify(body) : undefined,
         });
+        if (res.status === 204)
+            return { ok: true, data: {} };
         const data = await res.json();
-        if (!res.ok) {
+        if (!res.ok)
             return { ok: false, error: data.error || `HTTP ${res.status}` };
-        }
         return { ok: true, data };
     }
     catch (err) {
-        return { ok: false, error: err instanceof Error ? err.message : "Unknown error" };
+        return { ok: false, error: err.message || "Request failed" };
     }
 }
-// Tool definitions
+// ── Tool Definitions ────────────────────────────────────────────────────────
 const tools = [
+    // Account
     {
-        name: "vibekit_submit_task",
-        description: "Submit a coding task to VibeKit. The AI will write code, commit to GitHub, and deploy to Vercel. Returns a task ID to poll for results.",
+        name: "vibekit_account",
+        description: "Get account info: plan, balance, session usage.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    // Apps
+    {
+        name: "vibekit_list_apps",
+        description: "List all your hosted apps with status and URLs.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "vibekit_app_info",
+        description: "Get details about a specific app.",
+        inputSchema: {
+            type: "object",
+            properties: { slug: { type: "string", description: "App subdomain slug or full UUID" } },
+            required: ["slug"],
+        },
+    },
+    // Agent Chat
+    {
+        name: "vibekit_chat",
+        description: "Send a message to an app's AI agent. The agent can modify code, deploy, fix bugs, add features.",
         inputSchema: {
             type: "object",
             properties: {
-                task: {
-                    type: "string",
-                    description: "What you want built or changed. Be specific about features, design, and behavior.",
-                },
-                repo: {
-                    type: "string",
-                    description: "GitHub repo in format 'owner/repo'. Optional — will use user's current repo if not specified.",
-                },
-                branch: {
-                    type: "string",
-                    description: "Git branch to work on. Default: main",
-                },
-                deploy: {
-                    type: "boolean",
-                    description: "Auto-deploy to Vercel when done. Default: true",
-                },
-                callbackUrl: {
-                    type: "string",
-                    description: "Webhook URL to receive task completion notification.",
-                },
+                slug: { type: "string", description: "App subdomain slug" },
+                message: { type: "string", description: "Message for the AI agent" },
             },
-            required: ["task"],
+            required: ["slug", "message"],
         },
     },
     {
-        name: "vibekit_get_task",
-        description: "Get the status and result of a previously submitted task.",
+        name: "vibekit_agent_status",
+        description: "Get the AI agent's status and model info for an app.",
+        inputSchema: {
+            type: "object",
+            properties: { slug: { type: "string", description: "App subdomain slug" } },
+            required: ["slug"],
+        },
+    },
+    // Deploy
+    {
+        name: "vibekit_deploy",
+        description: "Trigger a redeploy for an app.",
+        inputSchema: {
+            type: "object",
+            properties: { slug: { type: "string", description: "App subdomain slug" } },
+            required: ["slug"],
+        },
+    },
+    {
+        name: "vibekit_deploys",
+        description: "List deploy history for an app.",
+        inputSchema: {
+            type: "object",
+            properties: { slug: { type: "string", description: "App subdomain slug" } },
+            required: ["slug"],
+        },
+    },
+    {
+        name: "vibekit_rollback",
+        description: "Rollback an app to a previous deploy.",
         inputSchema: {
             type: "object",
             properties: {
-                taskId: {
-                    type: "string",
-                    description: "The task ID returned from vibekit_submit_task",
-                },
+                slug: { type: "string", description: "App subdomain slug" },
+                deployId: { type: "string", description: "Deploy ID to rollback to" },
             },
-            required: ["taskId"],
+            required: ["slug", "deployId"],
         },
     },
+    // Logs
     {
-        name: "vibekit_list_tasks",
-        description: "List recent tasks submitted to VibeKit.",
+        name: "vibekit_logs",
+        description: "Get recent logs for an app.",
         inputSchema: {
             type: "object",
             properties: {
-                limit: {
-                    type: "number",
-                    description: "Max number of tasks to return. Default: 10",
-                },
-                status: {
-                    type: "string",
-                    enum: ["pending", "running", "completed", "failed"],
-                    description: "Filter by status",
-                },
+                slug: { type: "string", description: "App subdomain slug" },
+                lines: { type: "number", description: "Number of lines (default 50)" },
             },
+            required: ["slug"],
+        },
+    },
+    // Container control
+    {
+        name: "vibekit_start",
+        description: "Start an app's container.",
+        inputSchema: {
+            type: "object",
+            properties: { slug: { type: "string", description: "App subdomain slug" } },
+            required: ["slug"],
+        },
+    },
+    {
+        name: "vibekit_stop",
+        description: "Stop an app's container.",
+        inputSchema: {
+            type: "object",
+            properties: { slug: { type: "string", description: "App subdomain slug" } },
+            required: ["slug"],
         },
     },
     {
-        name: "vibekit_wait_for_task",
-        description: "Wait for a task to complete and return the result. Polls every 5 seconds up to the timeout.",
+        name: "vibekit_restart",
+        description: "Restart an app's container.",
+        inputSchema: {
+            type: "object",
+            properties: { slug: { type: "string", description: "App subdomain slug" } },
+            required: ["slug"],
+        },
+    },
+    // Env vars
+    {
+        name: "vibekit_env_list",
+        description: "List environment variables for an app.",
         inputSchema: {
             type: "object",
             properties: {
-                taskId: {
-                    type: "string",
-                    description: "The task ID to wait for",
-                },
-                timeoutSeconds: {
-                    type: "number",
-                    description: "Max seconds to wait. Default: 300 (5 minutes)",
-                },
+                slug: { type: "string", description: "App subdomain slug" },
+                reveal: { type: "boolean", description: "Show real values instead of masked" },
             },
-            required: ["taskId"],
+            required: ["slug"],
+        },
+    },
+    {
+        name: "vibekit_env_set",
+        description: "Set an environment variable.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: { type: "string", description: "App subdomain slug" },
+                key: { type: "string", description: "Variable name" },
+                value: { type: "string", description: "Variable value" },
+            },
+            required: ["slug", "key", "value"],
         },
     },
     {
-        name: "vibekit_create_schedule",
-        description: "Create a scheduled recurring task. The AI will run this task automatically on the specified schedule.",
+        name: "vibekit_env_delete",
+        description: "Delete an environment variable.",
         inputSchema: {
             type: "object",
             properties: {
-                task: {
-                    type: "string",
-                    description: "What to do on each run. e.g., 'Improve SEO and page speed'",
-                },
-                repo: {
-                    type: "string",
-                    description: "GitHub repo in format 'owner/repo'",
-                },
-                cron: {
-                    type: "string",
-                    description: "Cron expression. e.g., '0 9 * * 1' for every Monday at 9am UTC",
-                },
-                name: {
-                    type: "string",
-                    description: "Friendly name for the schedule",
-                },
+                slug: { type: "string", description: "App subdomain slug" },
+                key: { type: "string", description: "Variable name to delete" },
             },
-            required: ["task", "repo", "cron"],
+            required: ["slug", "key"],
         },
     },
+    // Database
     {
-        name: "vibekit_list_schedules",
-        description: "List all scheduled tasks.",
+        name: "vibekit_db_status",
+        description: "Get database status for an app (tables, size, connections).",
         inputSchema: {
             type: "object",
-            properties: {},
+            properties: { slug: { type: "string", description: "App subdomain slug" } },
+            required: ["slug"],
         },
     },
     {
-        name: "vibekit_delete_schedule",
-        description: "Delete a scheduled task.",
+        name: "vibekit_db_schema",
+        description: "Get database schema — tables, columns, types, foreign keys.",
+        inputSchema: {
+            type: "object",
+            properties: { slug: { type: "string", description: "App subdomain slug" } },
+            required: ["slug"],
+        },
+    },
+    {
+        name: "vibekit_db_query",
+        description: "Run a read-only SQL query against an app's database.",
         inputSchema: {
             type: "object",
             properties: {
-                scheduleId: {
-                    type: "string",
-                    description: "The schedule ID to delete",
-                },
+                slug: { type: "string", description: "App subdomain slug" },
+                sql: { type: "string", description: "SQL query (SELECT only)" },
             },
-            required: ["scheduleId"],
+            required: ["slug", "sql"],
         },
     },
     {
-        name: "vibekit_account",
-        description: "Get VibeKit account info including plan, credits balance, and usage.",
+        name: "vibekit_db_table",
+        description: "Browse data in a specific table.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: { type: "string", description: "App subdomain slug" },
+                table: { type: "string", description: "Table name" },
+                limit: { type: "number", description: "Max rows (default 20)" },
+            },
+            required: ["slug", "table"],
+        },
+    },
+    // Files
+    {
+        name: "vibekit_files",
+        description: "Browse workspace files for an app.",
         inputSchema: {
             type: "object",
-            properties: {},
+            properties: {
+                slug: { type: "string", description: "App subdomain slug" },
+                path: { type: "string", description: "Directory path (default: root)" },
+            },
+            required: ["slug"],
         },
     },
+    // QA
     {
-        name: "vibekit_list_skills",
-        description: "List all available implementation skills. Returns skill IDs, names, descriptions, and tags. Use this to discover what skills are available before fetching specific ones.",
+        name: "vibekit_qa",
+        description: "Run a QA audit on an app — checks for bugs, accessibility, performance issues.",
+        inputSchema: {
+            type: "object",
+            properties: { slug: { type: "string", description: "App subdomain slug" } },
+            required: ["slug"],
+        },
+    },
+    // Domain
+    {
+        name: "vibekit_set_domain",
+        description: "Set a custom domain for an app.",
         inputSchema: {
             type: "object",
             properties: {
-                tag: {
-                    type: "string",
-                    description: "Filter skills by tag (e.g., 'react', 'database', 'security')",
-                },
+                slug: { type: "string", description: "App subdomain slug" },
+                domain: { type: "string", description: "Custom domain (e.g. myapp.com)" },
             },
+            required: ["slug", "domain"],
         },
     },
+    // Tasks (headless API)
     {
-        name: "vibekit_get_skill",
-        description: "Fetch the full content of a specific skill. Skills contain implementation patterns, code examples, and best practices for a domain. Fetch skills on-demand when you need guidance on a specific topic.",
+        name: "vibekit_submit_task",
+        description: "Submit a coding task. An AI agent will build code and deploy it.",
         inputSchema: {
             type: "object",
             properties: {
-                id: {
-                    type: "string",
-                    description: "Skill ID from vibekit_list_skills (e.g., 'nextjs', 'trpc', 'auth')",
-                },
+                task: { type: "string", description: "What to build or change" },
+                repo: { type: "string", description: "GitHub repo (owner/repo)" },
+                branch: { type: "string", description: "Branch (default: main)" },
             },
-            required: ["id"],
+            required: ["task"],
+        },
+    },
+    {
+        name: "vibekit_task_status",
+        description: "Check status of a submitted task.",
+        inputSchema: {
+            type: "object",
+            properties: { taskId: { type: "string", description: "Task ID" } },
+            required: ["taskId"],
         },
     },
 ];
-// Tool handlers
+// ── Tool Handlers ───────────────────────────────────────────────────────────
 async function handleTool(name, args) {
     let result;
+    const s = args.slug;
+    const h = `/hosting/app/${s}`;
     switch (name) {
-        case "vibekit_submit_task":
-            result = await apiRequest("POST", "/task", {
-                task: args.task,
-                repo: args.repo,
-                branch: args.branch,
-                deploy: args.deploy ?? true,
-                callbackUrl: args.callbackUrl,
-            });
+        case "vibekit_account":
+            result = await api("GET", "/account");
             break;
-        case "vibekit_get_task":
-            result = await apiRequest("GET", `/task/${args.taskId}`);
+        case "vibekit_list_apps":
+            result = await api("GET", "/hosting/apps");
             break;
-        case "vibekit_list_tasks": {
-            let path = "/tasks";
-            const params = new URLSearchParams();
-            if (args.limit)
-                params.set("limit", String(args.limit));
-            if (args.status)
-                params.set("status", String(args.status));
-            if (params.toString())
-                path += `?${params.toString()}`;
-            result = await apiRequest("GET", path);
+        case "vibekit_app_info":
+            result = await api("GET", h);
             break;
-        }
-        case "vibekit_wait_for_task": {
-            const taskId = args.taskId;
-            const timeout = (args.timeoutSeconds || 300) * 1000;
-            const start = Date.now();
-            while (Date.now() - start < timeout) {
-                result = await apiRequest("GET", `/task/${taskId}`);
-                if (!result.ok)
-                    break;
-                const task = result.data;
-                if (task.status === "completed" || task.status === "failed") {
-                    break;
-                }
-                await new Promise((r) => setTimeout(r, 5000));
-            }
-            if (!result) {
-                result = { ok: false, error: "Timeout waiting for task" };
-            }
+        case "vibekit_chat":
+            result = await api("POST", `${h}/agent`, { message: args.message });
             break;
-        }
-        case "vibekit_create_schedule":
-            result = await apiRequest("POST", "/schedule", {
-                task: args.task,
-                repo: args.repo,
-                cron: args.cron,
-                name: args.name,
-            });
+        case "vibekit_agent_status":
+            result = await api("GET", `${h}/agent/status`);
             break;
-        case "vibekit_list_schedules":
-            result = await apiRequest("GET", "/schedules");
+        case "vibekit_deploy":
+            result = await api("POST", `${h}/redeploy`);
             break;
-        case "vibekit_delete_schedule":
-            result = await apiRequest("DELETE", `/schedule/${args.scheduleId}`);
+        case "vibekit_deploys":
+            result = await api("GET", `${h}/deploys`);
             break;
-        case "vibekit_account":
-            result = await apiRequest("GET", "/account");
+        case "vibekit_rollback":
+            result = await api("POST", `${h}/deploys/${args.deployId}/rollback`);
+            break;
+        case "vibekit_logs":
+            result = await api("GET", `${h}/logs?lines=${args.lines || 50}`);
+            break;
+        case "vibekit_start":
+            result = await api("POST", `${h}/start`);
+            break;
+        case "vibekit_stop":
+            result = await api("POST", `${h}/stop`);
+            break;
+        case "vibekit_restart":
+            result = await api("POST", `${h}/restart`);
+            break;
+        case "vibekit_env_list":
+            result = await api("GET", `${h}/env${args.reveal ? '?reveal=true' : ''}`);
+            break;
+        case "vibekit_env_set":
+            result = await api("POST", `${h}/env`, { vars: { [args.key]: args.value } });
+            break;
+        case "vibekit_env_delete":
+            result = await api("DELETE", `${h}/env/${args.key}`);
             break;
-        case "vibekit_list_skills": {
-            try {
-                // Check cache
-                if (skillsCache && Date.now() - skillsCache.fetchedAt < CACHE_TTL) {
-                    let skills = skillsCache.manifest.skills;
-                    if (args.tag) {
-                        skills = skills.filter((s) => s.tags?.includes(args.tag));
-                    }
-                    result = { ok: true, data: { skills } };
-                    break;
-                }
-                // Fetch manifest
-                const res = await fetch(`${SKILLS_REGISTRY}/skills.json`);
-                if (!res.ok) {
-                    result = { ok: false, error: `Failed to fetch skills: ${res.status}` };
-                    break;
-                }
-                const manifest = await res.json();
-                skillsCache = { manifest, fetchedAt: Date.now() };
-                let skills = manifest.skills;
-                if (args.tag) {
-                    skills = skills.filter((s) => s.tags?.includes(args.tag));
-                }
-                result = { ok: true, data: { skills, count: skills.length } };
-            }
-            catch (err) {
-                result = { ok: false, error: err instanceof Error ? err.message : "Unknown error" };
-            }
+        case "vibekit_db_status":
+            result = await api("GET", `${h}/database`);
             break;
-        }
-        case "vibekit_get_skill": {
-            try {
-                const id = args.id;
-                if (!id) {
-                    result = { ok: false, error: "Skill ID is required" };
-                    break;
-                }
-                const res = await fetch(`${SKILLS_REGISTRY}/skills/${id}/SKILL.md`);
-                if (!res.ok) {
-                    result = { ok: false, error: `Skill '${id}' not found (${res.status})` };
-                    break;
-                }
-                const content = await res.text();
-                result = { ok: true, data: { id, content } };
-            }
-            catch (err) {
-                result = { ok: false, error: err instanceof Error ? err.message : "Unknown error" };
-            }
+        case "vibekit_db_schema":
+            result = await api("GET", `${h}/database/schema`);
             break;
-        }
-        default:
-            result = { ok: false, error: `Unknown tool: ${name}` };
+        case "vibekit_db_query":
+            result = await api("POST", `${h}/database/query`, { sql: args.sql });
+            break;
+        case "vibekit_db_table":
+            result = await api("GET", `${h}/database/tables/${args.table}?limit=${args.limit || 20}`);
+            break;
+        case "vibekit_files":
+            result = await api("GET", `${h}/agent/files${args.path ? `?path=${encodeURIComponent(args.path)}` : ''}`);
+            break;
+        case "vibekit_qa":
+            result = await api("POST", `${h}/qa`);
+            break;
+        case "vibekit_set_domain":
+            result = await api("POST", `${h}/domain`, { domain: args.domain });
+            break;
+        case "vibekit_submit_task":
+            result = await api("POST", "/task", { prompt: args.task, repo: args.repo, branch: args.branch });
+            break;
+        case "vibekit_task_status":
+            result = await api("GET", `/task/${args.taskId}`);
+            break;
+        default: result = { ok: false, error: `Unknown tool: ${name}` };
     }
-    const text = result.ok
-        ? JSON.stringify(result.data, null, 2)
-        : `Error: ${result.error}`;
+    const text = result.ok ? JSON.stringify(result.data, null, 2) : `Error: ${result.error}`;
     return { content: [{ type: "text", text }] };
 }
-// Main server setup
-const server = new index_js_1.Server({
-    name: "vibekit-mcp",
-    version: "0.1.0",
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-// Handle tool listing
-server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-    tools,
-}));
-// Handle tool calls
+// ── Server ──────────────────────────────────────────────────────────────────
+const server = new index_js_1.Server({ name: "vibekit-mcp", version: "0.3.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools }));
 server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     return handleTool(name, (args || {}));
 });
-// Start server
 async function main() {
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
     console.error("VibeKit MCP server running on stdio");
 }
-main().catch((err) => {
-    console.error("Fatal error:", err);
-    process.exit(1);
-});
+main().catch((err) => { console.error("Fatal:", err); process.exit(1); });

package/package.json

@@ -1,41 +1,16 @@
 {
   "name": "vibekit-mcp",
-  "version": "0.2.0",
-  "description": "MCP server for VibeKit — use AI coding tasks as native tools in Claude Desktop, Cursor, etc.",
+  "version": "0.3.0",
+  "description": "MCP server for VibeKit — manage AI-powered apps as tools in Claude Desktop, Cursor, Windsurf, etc.",
   "main": "dist/index.js",
-  "bin": {
-    "vibekit-mcp": "./dist/index.js"
-  },
-  "files": [
-    "dist/",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "mcp",
-    "vibekit",
-    "claude",
-    "ai",
-    "coding",
-    "tools",
-    "anthropic"
-  ],
-  "author": "609.sol",
+  "bin": { "vibekit-mcp": "./dist/index.js" },
+  "files": ["dist/", "README.md"],
+  "scripts": { "build": "tsc", "prepublishOnly": "npm run build" },
+  "keywords": ["mcp", "vibekit", "claude", "cursor", "ai", "agent", "deploy", "model-context-protocol"],
+  "author": "VibeKit",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/609NFT/vibekit.git",
-    "directory": "packages/mcp-server"
-  },
   "homepage": "https://vibekit.bot",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0"
-  }
+  "repository": { "type": "git", "url": "https://github.com/vibekit-apps/vibekit-mcp" },
+  "dependencies": { "@modelcontextprotocol/sdk": "^1.0.0" },
+  "devDependencies": { "typescript": "^5.0.0", "@types/node": "^22.0.0" }
 }