ofw-mcp 1.0.0

package/README.md

@@ -0,0 +1,170 @@
+# OurFamilyWizard MCP
+
+A [Model Context Protocol](https://modelcontextprotocol.io) server that connects Claude to [OurFamilyWizard](https://www.ourfamilywizard.com), giving you natural-language access to your co-parenting messages, calendar, expenses, and journal.
+
+## What you can do
+
+Ask Claude things like:
+
+- *"Show me my recent OFW messages"*
+- *"What's on the kids' calendar next week?"*
+- *"List recent expenses and tell me what I owe"*
+- *"Add a journal entry about today's pickup"*
+- *"Draft a reply to the last message from my co-parent"*
+
+## Requirements
+
+- [Claude Desktop](https://claude.ai/download)
+- [Node.js](https://nodejs.org) 18 or later
+- An active OurFamilyWizard account
+
+## Installation
+
+### 1. Clone and build
+
+```bash
+git clone https://github.com/chrischall/ofw-mcp.git
+cd ofw-mcp
+npm install
+npm run build
+```
+
+### 2. Add to Claude Desktop
+
+Edit your Claude Desktop config file:
+
+- **Mac:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+
+Add the `ofw` entry inside `"mcpServers"` (create the key if it doesn't exist):
+
+```json
+{
+  "mcpServers": {
+    "ofw": {
+      "command": "node",
+      "args": ["/absolute/path/to/ofw-mcp/dist/index.js"],
+      "env": {
+        "OFW_USERNAME": "your-email@example.com",
+        "OFW_PASSWORD": "your-ofw-password"
+      }
+    }
+  }
+}
+```
+
+Replace `/absolute/path/to/ofw-mcp` with the actual path where you cloned the repo. On Mac, run `pwd` inside the cloned directory to get it.
+
+### 3. Restart Claude Desktop
+
+Quit completely (Cmd+Q on Mac, not just close the window) and relaunch.
+
+### 4. Verify
+
+Ask Claude: *"What does my OFW dashboard look like?"* — it should show your unread message count, upcoming events, and outstanding expenses.
+
+## Credentials
+
+Credentials are read from environment variables, with two ways to provide them:
+
+**Option A — env block in Claude Desktop config** (shown above, recommended):
+
+```json
+"env": {
+  "OFW_USERNAME": "your-email@example.com",
+  "OFW_PASSWORD": "your-ofw-password"
+}
+```
+
+**Option B — `.env` file** in the project directory:
+
+```bash
+cp .env.example .env
+# edit .env and fill in your credentials
+```
+
+Environment variables always take priority over the `.env` file. You can also pass them directly on the command line:
+
+```bash
+OFW_USERNAME=you@example.com OFW_PASSWORD=yourpass node dist/index.js
+```
+
+## Available tools
+
+Read-only tools run automatically. Write tools ask for your confirmation first.
+
+| Tool | What it does | Permission |
+|------|-------------|------------|
+| `ofw_get_profile` | Your profile and co-parent info | Auto |
+| `ofw_get_notifications` | Dashboard counts (unread messages, upcoming events, outstanding expenses) | Auto |
+| `ofw_list_message_folders` | Folders with unread counts — **get folder IDs here before listing messages** | Auto |
+| `ofw_list_messages` | Messages in a folder | Auto |
+| `ofw_get_message` | Full content of a single message | Auto |
+| `ofw_send_message` | Send a message | Confirm |
+| `ofw_list_events` | Calendar events in a date range | Auto |
+| `ofw_create_event` | Create a calendar event | Confirm |
+| `ofw_update_event` | Update a calendar event | Confirm |
+| `ofw_delete_event` | Delete a calendar event | Confirm |
+| `ofw_get_expense_totals` | Expense summary totals | Auto |
+| `ofw_list_expenses` | Expense history | Auto |
+| `ofw_create_expense` | Log a new expense | Confirm |
+| `ofw_list_journal_entries` | Journal entries | Auto |
+| `ofw_create_journal_entry` | Create a journal entry | Confirm |
+
+## Troubleshooting
+
+**"0 messages"** — Claude may have read the notification counts rather than the actual messages. Ask explicitly: *"List the messages in my OFW inbox"* or *"Use ofw_list_message_folders then ofw_list_messages"*.
+
+**"OFW_USERNAME and OFW_PASSWORD must be set"** — credentials are missing. Check the `env` block in your Claude Desktop config or your `.env` file.
+
+**403 Forbidden** — wrong credentials. Verify your username/password at [ofw.ourfamilywizard.com](https://ofw.ourfamilywizard.com).
+
+**Tools not appearing in Claude** — go to **Claude Desktop → Settings → Developer** to see connected servers and any error output. Make sure you fully quit and relaunched after editing the config.
+
+**Can't find the config file on Mac** — in Finder press Cmd+Shift+G and paste `~/Library/Application Support/Claude/`.
+
+## Security
+
+- Credentials live only in your local config file or `.env`
+- They are passed to the server as environment variables and never logged
+- The server authenticates with OFW using the same login flow as the web app
+- Use a strong, unique OFW password
+
+## Development
+
+```bash
+npm test        # run the test suite
+npm run build   # compile TypeScript → dist/
+```
+
+### Project structure
+
+```
+src/
+  client.ts       OFW auth and HTTP client
+  index.ts        MCP server entry point
+  tools/
+    user.ts       ofw_get_profile, ofw_get_notifications
+    messages.ts   folders, list, get, send
+    calendar.ts   list, create, update, delete events
+    expenses.ts   totals, list, create
+    journal.ts    list, create entries
+tests/
+  client.test.ts
+  tools/
+```
+
+### Auth flow
+
+OFW uses Spring Security form login:
+
+1. `GET /ofw/login.form` — establishes a session cookie
+2. `POST /ofw/login` — submits credentials, returns `{ auth: "<token>" }`
+3. All API calls use `Authorization: Bearer <token>`
+4. On 401, re-authenticates automatically and retries once
+
+Tokens are cached for 6 hours.
+
+## License
+
+MIT

package/dist/client.js

@@ -0,0 +1,96 @@
+import 'dotenv/config';
+const BASE_URL = 'https://ofw.ourfamilywizard.com';
+const STATIC_HEADERS = {
+    'ofw-client': 'WebApplication',
+    'ofw-version': '1.0.0',
+    Accept: 'application/json',
+    'Content-Type': 'application/json',
+};
+export class OFWClient {
+    token = null;
+    tokenExpiry = null;
+    async request(method, path, body) {
+        await this.ensureAuthenticated();
+        return this.doRequest(method, path, body, false);
+    }
+    async doRequest(method, path, body, isRetry) {
+        const response = await fetch(`${BASE_URL}${path}`, {
+            method,
+            headers: {
+                ...STATIC_HEADERS,
+                ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
+            },
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        if (response.status === 401 && !isRetry) {
+            this.token = null;
+            this.tokenExpiry = null;
+            await this.ensureAuthenticated();
+            return this.doRequest(method, path, body, true);
+        }
+        if (response.status === 429) {
+            if (!isRetry) {
+                await new Promise((r) => setTimeout(r, 2000));
+                return this.doRequest(method, path, body, true);
+            }
+            throw new Error('Rate limited by OFW API');
+        }
+        if (!response.ok) {
+            throw new Error(`OFW API error: ${response.status} ${response.statusText} for ${method} ${path}`);
+        }
+        return response.json();
+    }
+    async ensureAuthenticated() {
+        if (!this.isTokenExpiredSoon())
+            return;
+        await this.login();
+    }
+    async login() {
+        const username = process.env.OFW_USERNAME;
+        const password = process.env.OFW_PASSWORD;
+        if (!username || !password) {
+            throw new Error('OFW_USERNAME and OFW_PASSWORD must be set');
+        }
+        // Spring Security requires a SESSION cookie before accepting the login POST.
+        // GET /ofw/login.form with redirect:manual to capture the Set-Cookie from the 303 response.
+        const initResponse = await fetch(`${BASE_URL}/ofw/login.form`, {
+            headers: { 'ofw-client': 'WebApplication', 'ofw-version': '1.0.0' },
+            redirect: 'manual',
+        });
+        // Extract just the SESSION=value part (strip attributes like Path, Secure, etc.)
+        const setCookie = initResponse.headers.get('set-cookie') ?? '';
+        const sessionCookie = setCookie.split(';')[0] ?? null;
+        const response = await fetch(`${BASE_URL}/ofw/login`, {
+            method: 'POST',
+            headers: {
+                ...STATIC_HEADERS,
+                'Content-Type': 'application/x-www-form-urlencoded',
+                ...(sessionCookie ? { Cookie: sessionCookie } : {}),
+            },
+            body: new URLSearchParams({
+                submit: 'Sign In',
+                _eventId: 'submit',
+                username: username,
+                password,
+            }).toString(),
+        });
+        if (!response.ok) {
+            throw new Error(`OFW login failed: ${response.status} ${response.statusText}`);
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (!contentType.includes('application/json')) {
+            const body = await response.text();
+            throw new Error(`OFW login returned unexpected response (${contentType}): ${body.substring(0, 200)}`);
+        }
+        const data = (await response.json());
+        this.token = data.auth;
+        // Token expiry not returned by login endpoint; use 6h as a safe default
+        this.tokenExpiry = new Date(Date.now() + 6 * 60 * 60 * 1000);
+    }
+    isTokenExpiredSoon() {
+        if (!this.token || !this.tokenExpiry)
+            return true;
+        return this.tokenExpiry.getTime() - Date.now() < 5 * 60 * 1000;
+    }
+}
+export const client = new OFWClient();

package/dist/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { client } from './client.js';
+import { toolDefinitions as userTools, handleTool as handleUser } from './tools/user.js';
+import { toolDefinitions as messageTools, handleTool as handleMessages } from './tools/messages.js';
+import { toolDefinitions as calendarTools, handleTool as handleCalendar } from './tools/calendar.js';
+import { toolDefinitions as expenseTools, handleTool as handleExpenses } from './tools/expenses.js';
+import { toolDefinitions as journalTools, handleTool as handleJournal } from './tools/journal.js';
+const allTools = [
+    ...userTools,
+    ...messageTools,
+    ...calendarTools,
+    ...expenseTools,
+    ...journalTools,
+];
+const handlers = {};
+for (const tool of userTools)
+    handlers[tool.name] = (n, a) => handleUser(n, a, client);
+for (const tool of messageTools)
+    handlers[tool.name] = (n, a) => handleMessages(n, a, client);
+for (const tool of calendarTools)
+    handlers[tool.name] = (n, a) => handleCalendar(n, a, client);
+for (const tool of expenseTools)
+    handlers[tool.name] = (n, a) => handleExpenses(n, a, client);
+for (const tool of journalTools)
+    handlers[tool.name] = (n, a) => handleJournal(n, a, client);
+const server = new Server({ name: 'ofw', version: '1.0.0' }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: allTools }));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args = {} } = request.params;
+    const handler = handlers[name];
+    if (!handler) {
+        return {
+            content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+            isError: true,
+        };
+    }
+    try {
+        return await handler(name, args);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/calendar.js

@@ -0,0 +1,94 @@
+export const toolDefinitions = [
+    {
+        name: 'ofw_list_events',
+        description: 'List OurFamilyWizard calendar events in a date range',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                startDate: { type: 'string', description: 'Start date YYYY-MM-DD' },
+                endDate: { type: 'string', description: 'End date YYYY-MM-DD' },
+                detailed: { type: 'boolean', description: 'Return full event details (default false)' },
+            },
+            required: ['startDate', 'endDate'],
+        },
+    },
+    {
+        name: 'ofw_create_event',
+        description: 'Create a calendar event in OurFamilyWizard',
+        annotations: { destructiveHint: false },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string' },
+                startDate: { type: 'string', description: 'ISO datetime string' },
+                endDate: { type: 'string', description: 'ISO datetime string' },
+                allDay: { type: 'boolean' },
+                location: { type: 'string' },
+                reminder: { type: 'string', description: 'Reminder setting (e.g. "1 hour before")' },
+                privateEvent: { type: 'boolean' },
+                eventFor: { type: 'string', description: 'neither | parent1 | parent2' },
+                dropOffParent: { type: 'string' },
+                pickUpParent: { type: 'string' },
+                children: { type: 'array', items: { type: 'number' }, description: 'Array of child IDs' },
+            },
+            required: ['title', 'startDate', 'endDate'],
+        },
+    },
+    {
+        name: 'ofw_update_event',
+        description: 'Update an existing OurFamilyWizard calendar event',
+        annotations: { destructiveHint: false },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                eventId: { type: 'string' },
+                title: { type: 'string' },
+                startDate: { type: 'string' },
+                endDate: { type: 'string' },
+                allDay: { type: 'boolean' },
+                location: { type: 'string' },
+                reminder: { type: 'string' },
+                privateEvent: { type: 'boolean' },
+            },
+            required: ['eventId'],
+        },
+    },
+    {
+        name: 'ofw_delete_event',
+        description: 'Delete an OurFamilyWizard calendar event',
+        annotations: { destructiveHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: { eventId: { type: 'string', description: 'Event ID to delete' } },
+            required: ['eventId'],
+        },
+    },
+];
+export async function handleTool(name, args, client) {
+    switch (name) {
+        case 'ofw_list_events': {
+            const { startDate, endDate, detailed = false } = args;
+            const variant = detailed ? 'detailed' : 'basic';
+            const data = await client.request('GET', `/pub/v1/calendar/${variant}?startDate=${encodeURIComponent(startDate)}&endDate=${encodeURIComponent(endDate)}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'ofw_create_event': {
+            // Field names are best-guess; confirm via DevTools capture and update if needed (see pre-task note)
+            const data = await client.request('POST', '/pub/v1/calendar/events', args);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'ofw_update_event': {
+            const { eventId, ...updateData } = args;
+            const data = await client.request('PUT', `/pub/v1/calendar/events/${encodeURIComponent(eventId)}`, updateData);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'ofw_delete_event': {
+            const { eventId } = args;
+            await client.request('DELETE', `/pub/v1/calendar/events/${encodeURIComponent(eventId)}`);
+            return { content: [{ type: 'text', text: `Event ${eventId} deleted` }] };
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/dist/tools/expenses.js

@@ -0,0 +1,55 @@
+export const toolDefinitions = [
+    {
+        name: 'ofw_get_expense_totals',
+        description: 'Get OurFamilyWizard expense summary totals (owed/paid)',
+        annotations: { readOnlyHint: true },
+        inputSchema: { type: 'object', properties: {}, required: [] },
+    },
+    {
+        name: 'ofw_list_expenses',
+        description: 'List OurFamilyWizard expenses with pagination',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                start: { type: 'number', description: 'Start offset (default 0)' },
+                max: { type: 'number', description: 'Max results (default 20)' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'ofw_create_expense',
+        description: 'Log a new expense in OurFamilyWizard',
+        annotations: { destructiveHint: false },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                amount: { type: 'number', description: 'Expense amount' },
+                description: { type: 'string', description: 'Expense description' },
+                // Additional fields TBD — add after DevTools capture (see pre-task note)
+            },
+            required: ['amount', 'description'],
+        },
+    },
+];
+export async function handleTool(name, args, client) {
+    switch (name) {
+        case 'ofw_get_expense_totals': {
+            const data = await client.request('GET', '/pub/v2/expense/expenses/totals');
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'ofw_list_expenses': {
+            const { start = 0, max = 20 } = args;
+            const data = await client.request('GET', `/pub/v2/expense/expenses?start=${start}&max=${max}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'ofw_create_expense': {
+            // Field names are best-guess; confirm via DevTools capture and update if needed (see pre-task note)
+            const data = await client.request('POST', '/pub/v2/expense/expenses', args);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/dist/tools/journal.js

@@ -0,0 +1,46 @@
+export const toolDefinitions = [
+    {
+        name: 'ofw_list_journal_entries',
+        description: 'List OurFamilyWizard journal entries',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                start: { type: 'number', description: 'Start offset (default 1)' },
+                max: { type: 'number', description: 'Max results (default 10)' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'ofw_create_journal_entry',
+        description: 'Create a new journal entry in OurFamilyWizard',
+        annotations: { destructiveHint: false },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string', description: 'Entry title' },
+                body: { type: 'string', description: 'Entry text content' },
+                // Additional fields TBD — add after DevTools capture (see pre-task note)
+            },
+            required: ['title', 'body'],
+        },
+    },
+];
+export async function handleTool(name, args, client) {
+    switch (name) {
+        case 'ofw_list_journal_entries': {
+            // Journal API uses 1-based offset (unlike expenses which start at 0)
+            const { start = 1, max = 10 } = args;
+            const data = await client.request('GET', `/pub/v1/journals?start=${start}&max=${max}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'ofw_create_journal_entry': {
+            // Field names are best-guess; confirm via DevTools capture and update if needed (see pre-task note)
+            const data = await client.request('POST', '/pub/v1/journals', args);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/dist/tools/messages.js

@@ -0,0 +1,79 @@
+export const toolDefinitions = [
+    {
+        name: 'ofw_list_message_folders',
+        description: 'List OurFamilyWizard message folders (inbox, sent, etc.) and their unread counts. Returns folder IDs needed to call ofw_list_messages. Does NOT return message content.',
+        annotations: { readOnlyHint: true },
+        inputSchema: { type: 'object', properties: {}, required: [] },
+    },
+    {
+        name: 'ofw_list_messages',
+        description: 'List messages in an OurFamilyWizard folder. Call ofw_list_message_folders first to get folder IDs. Returns actual message content.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                folderId: { type: 'string', description: 'Folder ID (get from ofw_list_message_folders)' },
+                page: { type: 'number', description: 'Page number (default 1)' },
+                size: { type: 'number', description: 'Messages per page (default 50)' },
+            },
+            required: ['folderId'],
+        },
+    },
+    {
+        name: 'ofw_get_message',
+        description: 'Get a single OurFamilyWizard message by ID. Note: reading an unread message marks it as read.',
+        annotations: { readOnlyHint: false },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                messageId: { type: 'string', description: 'Message ID' },
+            },
+            required: ['messageId'],
+        },
+    },
+    {
+        name: 'ofw_send_message',
+        description: 'Send a message via OurFamilyWizard',
+        annotations: { destructiveHint: true },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                subject: { type: 'string', description: 'Message subject' },
+                body: { type: 'string', description: 'Message body text' },
+                recipients: {
+                    type: 'array',
+                    items: { type: 'number' },
+                    description: 'Array of recipient contact IDs (get from ofw_get_profile)',
+                },
+            },
+            required: ['subject', 'body', 'recipients'],
+        },
+    },
+];
+export async function handleTool(name, args, client) {
+    switch (name) {
+        case 'ofw_list_message_folders': {
+            const data = await client.request('GET', '/pub/v1/messageFolders?includeFolderCounts=true');
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'ofw_list_messages': {
+            const { folderId, page = 1, size = 50 } = args;
+            const path = `/pub/v3/messages?folders=${encodeURIComponent(folderId)}&page=${page}&size=${size}&sort=date&sortDirection=desc`;
+            const data = await client.request('GET', path);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'ofw_get_message': {
+            const { messageId } = args;
+            const data = await client.request('GET', `/pub/v3/messages/${encodeURIComponent(messageId)}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'ofw_send_message': {
+            const { subject, body, recipients } = args;
+            // Field names are best-guess; confirm via DevTools capture and update if needed (see pre-task note)
+            const data = await client.request('POST', '/pub/v3/messages', { subject, body, recipients });
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/dist/tools/user.js

@@ -0,0 +1,28 @@
+export const toolDefinitions = [
+    {
+        name: 'ofw_get_profile',
+        description: 'Get current user and co-parent profile information from OurFamilyWizard',
+        annotations: { readOnlyHint: true },
+        inputSchema: { type: 'object', properties: {}, required: [] },
+    },
+    {
+        name: 'ofw_get_notifications',
+        description: 'Get OurFamilyWizard dashboard summary: unread message count, upcoming events, outstanding expenses. Note: updates your last-seen status.',
+        annotations: { readOnlyHint: false },
+        inputSchema: { type: 'object', properties: {}, required: [] },
+    },
+];
+export async function handleTool(name, _args, client) {
+    switch (name) {
+        case 'ofw_get_profile': {
+            const data = await client.request('GET', '/pub/v2/profiles');
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        case 'ofw_get_notifications': {
+            const data = await client.request('GET', '/pub/v1/users/useraccountstatus');
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "ofw-mcp",
+  "version": "1.0.0",
+  "description": "OurFamilyWizard MCP server for Claude",
+  "type": "module",
+  "bin": {
+    "ofw-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "node --env-file=.env dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "dotenv": "^16.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  }
+}