mcp-server-moscow 0.0.1

package/README.dev.md

@@ -0,0 +1,81 @@
+# 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.
+- `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",
+        "MCP_TOKEN": "mcp_123.....",
+        "TOPIC": "mcp"
+      },
+      "disabled": false
+    }
+  }
+}
+```
+
+### Running Locally (Development)
+
+1.  **Install dependencies**:
+    ```bash
+    npm install
+    ```
+
+2.  **Build**:
+    ```bash
+    npm run build
+    ```
+
+### Deploy to NPM
+
+```markdown
+1.  **Login to NPM**:
+    ```bash
+    npm login
+    ```
+
+2.  **Publish**:
+    ```bash
+    npm publish --access public
+    ```
+
+After publishing, anyone can use your server with:
+```bash
+npx -y moscow-mcp-server
+```
+```
+
+## 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/README.md

@@ -0,0 +1,78 @@
+# Moscow MCP Server
+
+This is a **Model Context Protocol (MCP)** server for the **Moscow Task Management** system. It allows AI assistants like Claude Desktop or Antigravity to interact with your personal task list directly.
+
+## What is this for?
+
+By connecting this MCP server to your AI assistant, you can:
+-   **List your tasks**: Ask "What tasks do I have?"
+-   **Create tasks**: Say "Add a task to check email in the morning."
+-   **Update tasks**: "Mark the email task as done."
+-   **Manage priorities**: "Review my MUST priority tasks."
+
+## Prerequisites
+
+1.  **Sign Up**: You must have an account on the Moscow Task Manager app at [https://moscow-task.pages.dev/](https://moscow-task.pages.dev/).
+
+## How to Get Your Token
+
+To secure your task data, this MCP server requires a personal access token.
+
+1.  **Log in** to [https://moscow-task.pages.dev/](https://moscow-task.pages.dev/).
+2.  Open the **Settings** menu (click the gear icon or your profile).
+3.  Scroll down to the **Moscow MCP Tokens** section.
+4.  Enter a name for your token (e.g., "Claude Desktop") in the input field.
+5.  Click the **+ (Plus)** button to generate the token.
+6.  Click the **Copy** icon next to your new token to copy it to your clipboard.
+
+> **Keep this token secret!** It gives full access to your tasks.
+
+## Configuration
+
+### 1. Using with Claude Desktop
+
+Add the following to your Claude Desktop configuration file (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+
+```json
+{
+  "mcpServers": {
+    "moscow": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "mcp-server-moscow"
+      ],
+      "env": {
+        "MCP_TOKEN": "paste-your-token-here"
+      }
+    }
+  }
+}
+```
+
+*Replace `paste-your-token-here` with the token you copied from the website.*
+
+### 2. Manual / Local Development
+
+If you are running the server from source:
+
+1.  Clone the repository.
+2.  Install dependencies: `npm install`
+3.  Build the project: `npm run build`
+4.  Add to your MCP config using the full path to the built file:
+
+```json
+{
+  "mcpServers": {
+    "moscow-local": {
+      "command": "node",
+      "args": [
+        "/absolute/path/to/moscow-task/mcp-server/dist/index.js"
+      ],
+      "env": {
+        "MCP_TOKEN": "paste-your-token-here"
+      }
+    }
+  }
+}
+```

package/dist/index.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+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 || 'https://jnxbtfiwzaxwheifuhuf.supabase.co';
+const DEFAULT_TOPIC = process.env.TOPIC || 'default';
+if (!SUPABASE_URL) {
+    console.error('Missing SUPABASE_URL environment variable');
+    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;
+    switch (request.params.name) {
+        case 'list_tasks': {
+            try {
+                const response = await axios.get(getEdgeFunctionUrl(), {
+                    params: { topic: topicScope },
+                    headers: {
+                        Authorization: `Bearer ${authValue}`,
+                    },
+                });
+                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}`,
+                    },
+                });
+                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}`,
+                    },
+                });
+                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}`,
+                    },
+                });
+                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": "mcp-server-moscow",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "MCP 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"
+  }
+}