rosentry-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RoSentry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,186 @@
+# rosentry-mcp
+
+MCP (Model Context Protocol) server for [RoSentry](https://rosentry.dev) - AI-powered error monitoring for Roblox games.
+
+This package allows Claude and other MCP-compatible AI assistants to query, analyze, and manage errors from your Roblox games directly in conversation.
+
+## Features
+
+- **Query Errors** - Fetch recent errors with filters (level, user, place)
+- **Error Groups** - View deduplicated/grouped errors with occurrence counts
+- **Trends Analysis** - See error frequency over time (1h, 24h, 7d, 30d)
+- **Full-Text Search** - Search across error messages and stack traces
+- **User Impact** - See which Roblox users are affected by specific errors
+- **Status Management** - Resolve, ignore, or reopen error groups
+
+## Installation
+
+```bash
+npm install -g rosentry-mcp
+```
+
+Or use with npx (no install required):
+
+```bash
+npx rosentry-mcp
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `ROSENTRY_SUPABASE_URL` | Yes | Your Supabase project URL |
+| `ROSENTRY_SUPABASE_KEY` | Yes | Supabase service role key |
+| `ROSENTRY_API_KEY` | Yes | Your RoSentry project API key (`rs_...`) |
+
+### Claude Desktop Setup
+
+Add to your Claude Desktop config file:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "rosentry": {
+      "command": "npx",
+      "args": ["rosentry-mcp"],
+      "env": {
+        "ROSENTRY_SUPABASE_URL": "https://your-project.supabase.co",
+        "ROSENTRY_SUPABASE_KEY": "your-service-role-key",
+        "ROSENTRY_API_KEY": "rs_your_api_key"
+      }
+    }
+  }
+}
+```
+
+Or if installed globally:
+
+```json
+{
+  "mcpServers": {
+    "rosentry": {
+      "command": "rosentry-mcp",
+      "env": {
+        "ROSENTRY_SUPABASE_URL": "https://your-project.supabase.co",
+        "ROSENTRY_SUPABASE_KEY": "your-service-role-key",
+        "ROSENTRY_API_KEY": "rs_your_api_key"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### `get_recent_errors`
+Fetch recent error events with full details including stack traces and context.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `limit` | number | Max errors to return (default: 20, max: 100) |
+| `level` | string | Filter by level: `error`, `warn`, `info`, `debug` |
+| `user_id` | number | Filter by Roblox UserId |
+| `place_id` | number | Filter by Roblox PlaceId |
+| `search` | string | Search term for error messages |
+
+### `get_error_groups`
+Fetch grouped/deduplicated errors showing occurrence counts and status.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `limit` | number | Max groups to return (default: 20, max: 50) |
+| `status` | string | Filter by status: `open`, `resolved`, `ignored` |
+| `search` | string | Search term for error messages |
+
+### `get_error_group_details`
+Get detailed info about a specific error group including individual events.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `group_id` | string | **Required.** UUID of the error group |
+| `include_events` | boolean | Include individual events (default: true) |
+| `events_limit` | number | Max events to include (default: 10) |
+
+### `get_error_trends`
+Get error frequency trends over time.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `timeframe` | string | Time range: `1h`, `24h`, `7d`, `30d` (default: 24h) |
+| `group_by` | string | Grouping: `hour` or `day` |
+
+### `search_errors`
+Full-text search across error messages and stack traces.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `query` | string | **Required.** Search query |
+| `limit` | number | Max results (default: 20) |
+
+### `get_affected_users`
+Get Roblox users affected by a specific error group.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `group_id` | string | **Required.** UUID of the error group |
+| `limit` | number | Max users to return (default: 50) |
+
+### `get_stats`
+Get summary statistics for your project.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `timeframe` | string | Time range: `1h`, `24h`, `7d`, `30d` (default: 24h) |
+
+Returns: Total errors, errors by level, open groups count, affected users, top 5 errors.
+
+### `update_error_status`
+Update the status of an error group.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `group_id` | string | **Required.** UUID of the error group |
+| `status` | string | **Required.** New status: `open`, `resolved`, `ignored` |
+
+## Example Usage with Claude
+
+Once configured, you can ask Claude things like:
+
+- *"What errors happened in the last hour?"*
+- *"Show me the top errors affecting users"*
+- *"Search for errors related to 'DataStore'"*
+- *"How many users are affected by error group abc-123?"*
+- *"Mark that error as resolved"*
+- *"What's the error trend for the past week?"*
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/rosentry/rosentry.git
+cd rosentry/mcp
+
+# Install dependencies
+npm install
+
+# Run in development
+npm run dev
+
+# Build for production
+npm run build
+```
+
+## Related
+
+- [RoSentry](https://rosentry.dev) - Error monitoring platform for Roblox
+- [RoSentry Lua SDK](https://github.com/rosentry/rosentry/tree/main/sdk) - Roblox Lua SDK
+- [Model Context Protocol](https://modelcontextprotocol.io) - MCP specification
+
+## License
+
+MIT - see [LICENSE](./LICENSE)

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,535 @@
+#!/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 { createClient } from "@supabase/supabase-js";
+// Initialize Supabase client
+const supabaseUrl = process.env.ROSENTRY_SUPABASE_URL;
+const supabaseKey = process.env.ROSENTRY_SUPABASE_KEY;
+const projectApiKey = process.env.ROSENTRY_API_KEY;
+let supabase = null;
+let projectId = null;
+async function initializeClient() {
+    if (!supabaseUrl || !supabaseKey) {
+        throw new Error("Missing ROSENTRY_SUPABASE_URL or ROSENTRY_SUPABASE_KEY environment variables");
+    }
+    supabase = createClient(supabaseUrl, supabaseKey);
+    // If API key is provided, get the project ID
+    if (projectApiKey) {
+        const { data: project } = await supabase
+            .from("projects")
+            .select("id")
+            .eq("api_key", projectApiKey)
+            .single();
+        if (project) {
+            projectId = project.id;
+        }
+    }
+}
+// Tool definitions
+const tools = [
+    {
+        name: "get_recent_errors",
+        description: "Fetch recent errors from RoSentry. Returns individual error events with full details including stack traces, user context, and metadata.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Maximum number of errors to return (default: 20, max: 100)",
+                },
+                level: {
+                    type: "string",
+                    enum: ["error", "warn", "info", "debug"],
+                    description: "Filter by error level",
+                },
+                user_id: {
+                    type: "number",
+                    description: "Filter by Roblox UserId",
+                },
+                place_id: {
+                    type: "number",
+                    description: "Filter by Roblox PlaceId",
+                },
+                search: {
+                    type: "string",
+                    description: "Search term to filter error messages",
+                },
+            },
+        },
+    },
+    {
+        name: "get_error_groups",
+        description: "Fetch grouped/deduplicated errors from RoSentry. Error groups combine similar errors by fingerprint, showing occurrence count and status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Maximum number of groups to return (default: 20, max: 50)",
+                },
+                status: {
+                    type: "string",
+                    enum: ["open", "resolved", "ignored"],
+                    description: "Filter by group status",
+                },
+                search: {
+                    type: "string",
+                    description: "Search term to filter error messages",
+                },
+            },
+        },
+    },
+    {
+        name: "get_error_group_details",
+        description: "Get detailed information about a specific error group, including all individual error events in that group.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                group_id: {
+                    type: "string",
+                    description: "The UUID of the error group",
+                },
+                include_events: {
+                    type: "boolean",
+                    description: "Include individual error events (default: true)",
+                },
+                events_limit: {
+                    type: "number",
+                    description: "Maximum number of events to include (default: 10)",
+                },
+            },
+            required: ["group_id"],
+        },
+    },
+    {
+        name: "get_error_trends",
+        description: "Get error frequency trends over time. Useful for understanding when errors spike or identifying patterns.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                timeframe: {
+                    type: "string",
+                    enum: ["1h", "24h", "7d", "30d"],
+                    description: "Time range for trends (default: 24h)",
+                },
+                group_by: {
+                    type: "string",
+                    enum: ["hour", "day"],
+                    description: "How to group the data points",
+                },
+            },
+        },
+    },
+    {
+        name: "search_errors",
+        description: "Full-text search across all error messages and stack traces. Returns matching errors with context.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query string",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum results to return (default: 20)",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "get_affected_users",
+        description: "Get list of Roblox users affected by a specific error group. Helpful for understanding impact.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                group_id: {
+                    type: "string",
+                    description: "The UUID of the error group",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum users to return (default: 50)",
+                },
+            },
+            required: ["group_id"],
+        },
+    },
+    {
+        name: "get_stats",
+        description: "Get summary statistics for error monitoring - total errors, errors by level, affected users, and top errors.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                timeframe: {
+                    type: "string",
+                    enum: ["1h", "24h", "7d", "30d"],
+                    description: "Time range for stats (default: 24h)",
+                },
+            },
+        },
+    },
+    {
+        name: "update_error_status",
+        description: "Update the status of an error group (resolve, ignore, or reopen).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                group_id: {
+                    type: "string",
+                    description: "The UUID of the error group",
+                },
+                status: {
+                    type: "string",
+                    enum: ["open", "resolved", "ignored"],
+                    description: "New status for the error group",
+                },
+            },
+            required: ["group_id", "status"],
+        },
+    },
+];
+// Tool handlers
+async function handleGetRecentErrors(args) {
+    if (!supabase || !projectId) {
+        return { error: "Not connected to RoSentry" };
+    }
+    const limit = Math.min(args.limit ?? 20, 100);
+    let query = supabase
+        .from("errors")
+        .select("*")
+        .eq("project_id", projectId)
+        .order("timestamp", { ascending: false })
+        .limit(limit);
+    if (args.level)
+        query = query.eq("level", args.level);
+    if (args.user_id)
+        query = query.eq("user_id", args.user_id);
+    if (args.place_id)
+        query = query.eq("place_id", args.place_id);
+    if (args.search)
+        query = query.ilike("message", `%${args.search}%`);
+    const { data, error } = await query;
+    if (error)
+        return { error: error.message };
+    return { errors: data, count: data?.length ?? 0 };
+}
+async function handleGetErrorGroups(args) {
+    if (!supabase || !projectId) {
+        return { error: "Not connected to RoSentry" };
+    }
+    const limit = Math.min(args.limit ?? 20, 50);
+    let query = supabase
+        .from("error_groups")
+        .select("*")
+        .eq("project_id", projectId)
+        .order("last_seen", { ascending: false })
+        .limit(limit);
+    if (args.status)
+        query = query.eq("status", args.status);
+    if (args.search)
+        query = query.ilike("message", `%${args.search}%`);
+    const { data, error } = await query;
+    if (error)
+        return { error: error.message };
+    return { groups: data, count: data?.length ?? 0 };
+}
+async function handleGetErrorGroupDetails(args) {
+    if (!supabase || !projectId) {
+        return { error: "Not connected to RoSentry" };
+    }
+    // Get group
+    const { data: group, error: groupError } = await supabase
+        .from("error_groups")
+        .select("*")
+        .eq("id", args.group_id)
+        .eq("project_id", projectId)
+        .single();
+    if (groupError)
+        return { error: groupError.message };
+    if (!group)
+        return { error: "Error group not found" };
+    const result = { group };
+    // Get events if requested
+    if (args.include_events !== false) {
+        const { data: events } = await supabase
+            .from("errors")
+            .select("*")
+            .eq("error_group_id", args.group_id)
+            .order("timestamp", { ascending: false })
+            .limit(args.events_limit ?? 10);
+        result.events = events ?? [];
+    }
+    return result;
+}
+async function handleGetErrorTrends(args) {
+    if (!supabase || !projectId) {
+        return { error: "Not connected to RoSentry" };
+    }
+    const timeframe = args.timeframe ?? "24h";
+    const now = new Date();
+    let since;
+    switch (timeframe) {
+        case "1h":
+            since = new Date(now.getTime() - 60 * 60 * 1000);
+            break;
+        case "7d":
+            since = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+            break;
+        case "30d":
+            since = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+            break;
+        default:
+            since = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    }
+    const { data: errors } = await supabase
+        .from("errors")
+        .select("timestamp, level")
+        .eq("project_id", projectId)
+        .gte("timestamp", since.toISOString())
+        .order("timestamp", { ascending: true });
+    if (!errors)
+        return { trends: [], timeframe };
+    // Group by time bucket
+    const groupBy = args.group_by ?? (timeframe === "1h" ? "hour" : "day");
+    const buckets = {};
+    for (const error of errors) {
+        const date = new Date(error.timestamp);
+        let key;
+        if (groupBy === "hour") {
+            key = `${date.toISOString().slice(0, 13)}:00`;
+        }
+        else {
+            key = date.toISOString().slice(0, 10);
+        }
+        if (!buckets[key]) {
+            buckets[key] = { count: 0, errors: 0, warnings: 0 };
+        }
+        buckets[key].count++;
+        if (error.level === "error")
+            buckets[key].errors++;
+        if (error.level === "warn")
+            buckets[key].warnings++;
+    }
+    const trends = Object.entries(buckets).map(([time, data]) => ({
+        time,
+        ...data,
+    }));
+    return { trends, timeframe, group_by: groupBy };
+}
+async function handleSearchErrors(args) {
+    if (!supabase || !projectId) {
+        return { error: "Not connected to RoSentry" };
+    }
+    const limit = Math.min(args.limit ?? 20, 100);
+    // Search in messages and stack traces
+    const { data: messageMatches } = await supabase
+        .from("errors")
+        .select("*")
+        .eq("project_id", projectId)
+        .ilike("message", `%${args.query}%`)
+        .order("timestamp", { ascending: false })
+        .limit(limit);
+    const { data: stackMatches } = await supabase
+        .from("errors")
+        .select("*")
+        .eq("project_id", projectId)
+        .ilike("stack_trace", `%${args.query}%`)
+        .order("timestamp", { ascending: false })
+        .limit(limit);
+    // Combine and dedupe
+    const seen = new Set();
+    const results = [];
+    for (const error of [...(messageMatches ?? []), ...(stackMatches ?? [])]) {
+        if (!seen.has(error.id)) {
+            seen.add(error.id);
+            results.push(error);
+        }
+        if (results.length >= limit)
+            break;
+    }
+    return { results, count: results.length, query: args.query };
+}
+async function handleGetAffectedUsers(args) {
+    if (!supabase || !projectId) {
+        return { error: "Not connected to RoSentry" };
+    }
+    const limit = Math.min(args.limit ?? 50, 200);
+    const { data: errors } = await supabase
+        .from("errors")
+        .select("user_id, timestamp")
+        .eq("error_group_id", args.group_id)
+        .not("user_id", "is", null)
+        .order("timestamp", { ascending: false });
+    if (!errors)
+        return { users: [], count: 0 };
+    // Dedupe users and count occurrences
+    const userStats = {};
+    for (const error of errors) {
+        if (error.user_id) {
+            if (!userStats[error.user_id]) {
+                userStats[error.user_id] = { count: 0, last_seen: error.timestamp };
+            }
+            userStats[error.user_id].count++;
+        }
+    }
+    const users = Object.entries(userStats)
+        .map(([userId, stats]) => ({
+        user_id: parseInt(userId),
+        occurrence_count: stats.count,
+        last_seen: stats.last_seen,
+    }))
+        .sort((a, b) => b.occurrence_count - a.occurrence_count)
+        .slice(0, limit);
+    return { users, total_affected: Object.keys(userStats).length };
+}
+async function handleGetStats(args) {
+    if (!supabase || !projectId) {
+        return { error: "Not connected to RoSentry" };
+    }
+    const timeframe = args.timeframe ?? "24h";
+    const now = new Date();
+    let since;
+    switch (timeframe) {
+        case "1h":
+            since = new Date(now.getTime() - 60 * 60 * 1000);
+            break;
+        case "7d":
+            since = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+            break;
+        case "30d":
+            since = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+            break;
+        default:
+            since = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    }
+    // Get total errors
+    const { count: totalErrors } = await supabase
+        .from("errors")
+        .select("*", { count: "exact", head: true })
+        .eq("project_id", projectId)
+        .gte("timestamp", since.toISOString());
+    // Get errors by level
+    const { data: levelData } = await supabase
+        .from("errors")
+        .select("level")
+        .eq("project_id", projectId)
+        .gte("timestamp", since.toISOString());
+    const byLevel = (levelData ?? []).reduce((acc, { level }) => {
+        acc[level] = (acc[level] ?? 0) + 1;
+        return acc;
+    }, {});
+    // Get open groups
+    const { count: openGroups } = await supabase
+        .from("error_groups")
+        .select("*", { count: "exact", head: true })
+        .eq("project_id", projectId)
+        .eq("status", "open");
+    // Get unique users
+    const { data: userData } = await supabase
+        .from("errors")
+        .select("user_id")
+        .eq("project_id", projectId)
+        .gte("timestamp", since.toISOString())
+        .not("user_id", "is", null);
+    const uniqueUsers = new Set(userData?.map((e) => e.user_id)).size;
+    // Get top errors
+    const { data: topErrors } = await supabase
+        .from("error_groups")
+        .select("id, message, count, status")
+        .eq("project_id", projectId)
+        .eq("status", "open")
+        .order("count", { ascending: false })
+        .limit(5);
+    return {
+        timeframe,
+        total_errors: totalErrors ?? 0,
+        by_level: byLevel,
+        open_groups: openGroups ?? 0,
+        affected_users: uniqueUsers,
+        top_errors: topErrors ?? [],
+    };
+}
+async function handleUpdateErrorStatus(args) {
+    if (!supabase || !projectId) {
+        return { error: "Not connected to RoSentry" };
+    }
+    const { error } = await supabase
+        .from("error_groups")
+        .update({ status: args.status, updated_at: new Date().toISOString() })
+        .eq("id", args.group_id)
+        .eq("project_id", projectId);
+    if (error)
+        return { error: error.message };
+    return { success: true, group_id: args.group_id, new_status: args.status };
+}
+// Main server setup
+async function main() {
+    await initializeClient();
+    const server = new Server({
+        name: "rosentry-mcp",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // List tools handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools,
+    }));
+    // Call tool handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            let result;
+            switch (name) {
+                case "get_recent_errors":
+                    result = await handleGetRecentErrors(args);
+                    break;
+                case "get_error_groups":
+                    result = await handleGetErrorGroups(args);
+                    break;
+                case "get_error_group_details":
+                    result = await handleGetErrorGroupDetails(args);
+                    break;
+                case "get_error_trends":
+                    result = await handleGetErrorTrends(args);
+                    break;
+                case "search_errors":
+                    result = await handleSearchErrors(args);
+                    break;
+                case "get_affected_users":
+                    result = await handleGetAffectedUsers(args);
+                    break;
+                case "get_stats":
+                    result = await handleGetStats(args);
+                    break;
+                case "update_error_status":
+                    result = await handleUpdateErrorStatus(args);
+                    break;
+                default:
+                    return {
+                        content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                        isError: true,
+                    };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error}` }],
+                isError: true,
+            };
+        }
+    });
+    // Connect via stdio
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("RoSentry MCP server running");
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "rosentry-mcp",
+  "version": "0.1.0",
+  "description": "MCP (Model Context Protocol) server for RoSentry - AI-powered error monitoring for Roblox",
+  "author": "RoSentry",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "rosentry-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "rosentry",
+    "roblox",
+    "error-monitoring",
+    "sentry",
+    "claude",
+    "ai",
+    "debugging"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rosentry/rosentry.git",
+    "directory": "mcp"
+  },
+  "homepage": "https://rosentry.dev",
+  "bugs": {
+    "url": "https://github.com/rosentry/rosentry/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@supabase/supabase-js": "^2.50.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.0.0"
+  }
+}