moscow-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,64 @@
+# Moscow MCP Server (Local Adapter)
+
+A Model Context Protocol (MCP) server that provides tools to interact with the Moscow task management system via Supabase Edge Functions.
+
+This server is designed to run locally (as a "Local Adapter") and communicate with your remote Supabase instance via standard HTTP requests.
+
+## Prerequisites
+
+- Node.js (v18 or higher)
+- A Supabase project with the Moscow task management Edge Functions deployed.
+
+## Configuration
+
+The server requires the following environment variables. You can set them in a `.env` file in the root directory or pass them via your MCP client configuration.
+
+- `SUPABASE_URL`: The URL of your Supabase project.
+- `SUPABASE_ANON_KEY`: The anonymous API key for your Supabase project.
+- `MCP_TOKEN` (Optional): A custom token for authorization if your Edge Functions require it.
+
+## Usage
+
+### Using with Claude Desktop or Antigravity
+
+Add the following to your MCP configuration file (e.g., `claude_desktop_config.json` or `mcp_config.json`):
+
+```json
+{
+  "mcpServers": {
+     "moscow": {
+      "command": "node",
+      "args": [
+        "/Users/guiller/WebstormProjects/moscow-task/mcp-server/dist/index.js",
+        "--stdio"
+      ],
+      "env": {
+      "SUPABASE_URL": "https://your-project.supabase.co",
+        "SUPABASE_ANON_KEY": "your-anon-key",
+        "MCP_TOKEN": "mcp_123.....",
+        "TOPIC": "mcp"
+      },
+      "disabled": false
+    }
+  }
+}
+```
+
+### Running Locally (Development)
+
+1.  **Install dependencies**:
+    ```bash
+    npm install
+    ```
+
+2.  **Build**:
+    ```bash
+    npm run build
+    ```
+
+## Tools Provided
+
+- `list_tasks`: List tasks from the Moscow project. Can be filtered by `topic`.
+- `create_task`: Create a new task.
+- `update_task`: Update an existing task.
+- `delete_task`: Delete a task.

package/dist/index.js

@@ -0,0 +1,268 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, ErrorCode, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import axios from 'axios';
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+import path from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Load .env from the project root relative to this file's location
+dotenv.config({ path: path.resolve(__dirname, '../.env') });
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY;
+const DEFAULT_TOPIC = process.env.TOPIC || 'default';
+if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+    console.error('Missing SUPABASE_URL or SUPABASE_ANON_KEY environment variables');
+    process.exit(1);
+}
+const server = new Server({
+    name: 'moscow-mcp-server',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+const getEdgeFunctionUrl = () => `${SUPABASE_URL}/functions/v1/tasks`;
+// Tool Handlers
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: 'list_tasks',
+            description: 'List tasks for the current user and optionally filter by topic.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    topic: {
+                        type: 'string',
+                        description: 'Optional topic to filter tasks by.',
+                    },
+                },
+            },
+        },
+        {
+            name: 'create_task',
+            description: 'Create a new task.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    title: {
+                        type: 'string',
+                        description: 'The title of the task.',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'A detailed description of the task.',
+                    },
+                    topic: {
+                        type: 'string',
+                        description: 'The topic/category of the task.',
+                    },
+                    priority: {
+                        type: 'string',
+                        enum: ['MUST', 'SHOULD', 'COULD', 'WONT'],
+                        description: 'The priority of the task.',
+                    },
+                    status: {
+                        type: 'string',
+                        enum: ['TODO', 'IN_PROGRESS', 'DONE'],
+                        description: 'The status of the task.',
+                    },
+                },
+                required: ['title'],
+            },
+        },
+        {
+            name: 'update_task',
+            description: 'Update an existing task.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        description: 'The ID of the task to update.',
+                    },
+                    title: {
+                        type: 'string',
+                        description: 'The new title of the task.',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'The new description of the task.',
+                    },
+                    topic: {
+                        type: 'string',
+                        description: 'The new topic/category of the task.',
+                    },
+                    priority: {
+                        type: 'string',
+                        enum: ['MUST', 'SHOULD', 'COULD', 'WONT'],
+                        description: 'The new priority.',
+                    },
+                    status: {
+                        type: 'string',
+                        enum: ['TODO', 'IN_PROGRESS', 'DONE'],
+                        description: 'The new status.',
+                    },
+                },
+                required: ['id'],
+            },
+        },
+        {
+            name: 'delete_task',
+            description: 'Delete a task.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        description: 'The ID of the task to delete.',
+                    },
+                },
+                required: ['id'],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+    // Extract dynamic auth from the transport metadata if available
+    const env = extra?.env || {};
+    const mcpToken = env.MCP_TOKEN || process.env.MCP_TOKEN;
+    const topicScope = request.params.arguments?.topic || env.TOPIC || DEFAULT_TOPIC;
+    const authValue = mcpToken || SUPABASE_ANON_KEY;
+    switch (request.params.name) {
+        case 'list_tasks': {
+            try {
+                const response = await axios.get(getEdgeFunctionUrl(), {
+                    params: { topic: topicScope },
+                    headers: {
+                        Authorization: `Bearer ${authValue}`,
+                        apikey: SUPABASE_ANON_KEY,
+                    },
+                });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(response.data, null, 2) }],
+                };
+            }
+            catch (error) {
+                const errorMessage = axios.isAxiosError(error)
+                    ? error.response?.data?.error || error.message
+                    : error instanceof Error
+                        ? error.message
+                        : String(error);
+                return {
+                    content: [{ type: 'text', text: `Error listing tasks: ${errorMessage}` }],
+                    isError: true,
+                };
+            }
+        }
+        case 'create_task': {
+            const { title, description, topic, priority, status } = request.params.arguments || {};
+            try {
+                const response = await axios.post(getEdgeFunctionUrl(), {
+                    title,
+                    description,
+                    topic: topic || topicScope,
+                    priority,
+                    status,
+                }, {
+                    headers: {
+                        Authorization: `Bearer ${authValue}`,
+                        apikey: SUPABASE_ANON_KEY,
+                    },
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Task created successfully: ${JSON.stringify(response.data, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                const errorMessage = axios.isAxiosError(error)
+                    ? error.response?.data?.error || error.message
+                    : error instanceof Error
+                        ? error.message
+                        : String(error);
+                return {
+                    content: [{ type: 'text', text: `Error creating task: ${errorMessage}` }],
+                    isError: true,
+                };
+            }
+        }
+        case 'update_task': {
+            const { id, ...updates } = request.params.arguments || {};
+            try {
+                const response = await axios.patch(getEdgeFunctionUrl(), {
+                    id,
+                    ...updates,
+                }, {
+                    headers: {
+                        Authorization: `Bearer ${authValue}`,
+                        apikey: SUPABASE_ANON_KEY,
+                    },
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Task updated successfully: ${JSON.stringify(response.data, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                const errorMessage = axios.isAxiosError(error)
+                    ? error.response?.data?.error || error.message
+                    : error instanceof Error
+                        ? error.message
+                        : String(error);
+                return {
+                    content: [{ type: 'text', text: `Error updating task: ${errorMessage}` }],
+                    isError: true,
+                };
+            }
+        }
+        case 'delete_task': {
+            const { id } = request.params.arguments || {};
+            try {
+                await axios.delete(getEdgeFunctionUrl(), {
+                    params: { id },
+                    headers: {
+                        Authorization: `Bearer ${authValue}`,
+                        apikey: SUPABASE_ANON_KEY,
+                    },
+                });
+                return {
+                    content: [{ type: 'text', text: `Task ${id} deleted successfully.` }],
+                };
+            }
+            catch (error) {
+                const errorMessage = axios.isAxiosError(error)
+                    ? error.response?.data?.error || error.message
+                    : error instanceof Error
+                        ? error.message
+                        : String(error);
+                return {
+                    content: [{ type: 'text', text: `Error deleting task: ${errorMessage}` }],
+                    isError: true,
+                };
+            }
+        }
+        default:
+            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+    }
+});
+// STARTUP LOGIC: Always use Stdio
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Moscow MCP Server running on Stdio');
+}
+main().catch((error) => {
+    console.error('Server error:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "moscow-mcp-server",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "MCP server for Moscow task management",
+  "main": "dist/index.js",
+  "bin": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.6.0",
+    "axios": "^1.6.0",
+    "dotenv": "^16.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.8.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  }
+}