ofw-mcp 2.0.1 → 2.0.3

package/dist/index.js

@@ -1,53 +1,18 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.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: '2.0.1' }, { 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,
-        };
-    }
-});
+import { registerUserTools } from './tools/user.js';
+import { registerMessageTools } from './tools/messages.js';
+import { registerCalendarTools } from './tools/calendar.js';
+import { registerExpenseTools } from './tools/expenses.js';
+import { registerJournalTools } from './tools/journal.js';
+const server = new McpServer({ name: 'ofw', version: '2.0.3' });
+registerUserTools(server, client);
+registerMessageTools(server, client);
+registerCalendarTools(server, client);
+registerExpenseTools(server, client);
+registerJournalTools(server, client);
 console.error('[ofw-mcp] This project was developed and is maintained by AI (Claude Sonnet 4.6). Use at your own discretion.');
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/tools/calendar.js

@@ -1,94 +1,64 @@
-export const toolDefinitions = [
-    {
-        name: 'ofw_list_events',
+import { z } from 'zod';
+export function registerCalendarTools(server, client) {
+    server.registerTool('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'],
+            startDate: z.string().describe('Start date YYYY-MM-DD'),
+            endDate: z.string().describe('End date YYYY-MM-DD'),
+            detailed: z.boolean().describe('Return full event details (default false)').optional(),
         },
-    },
-    {
-        name: 'ofw_create_event',
+    }, async (args) => {
+        const variant = args.detailed ? 'detailed' : 'basic';
+        const data = await client.request('GET', `/pub/v1/calendar/${variant}?startDate=${encodeURIComponent(args.startDate)}&endDate=${encodeURIComponent(args.endDate)}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('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'],
+            title: z.string(),
+            startDate: z.string().describe('ISO datetime string'),
+            endDate: z.string().describe('ISO datetime string'),
+            allDay: z.boolean().optional(),
+            location: z.string().optional(),
+            reminder: z.string().describe('Reminder setting (e.g. "1 hour before")').optional(),
+            privateEvent: z.boolean().optional(),
+            eventFor: z.string().describe('neither | parent1 | parent2').optional(),
+            dropOffParent: z.string().optional(),
+            pickUpParent: z.string().optional(),
+            children: z.array(z.number()).describe('Array of child IDs').optional(),
         },
-    },
-    {
-        name: 'ofw_update_event',
+    }, async (args) => {
+        const data = await client.request('POST', '/pub/v1/calendar/events', args);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('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'],
+            eventId: z.string(),
+            title: z.string().optional(),
+            startDate: z.string().optional(),
+            endDate: z.string().optional(),
+            allDay: z.boolean().optional(),
+            location: z.string().optional(),
+            reminder: z.string().optional(),
+            privateEvent: z.boolean().optional(),
         },
-    },
-    {
-        name: 'ofw_delete_event',
+    }, async (args) => {
+        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) }] };
+    });
+    server.registerTool('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'],
+            eventId: z.string().describe('Event ID to delete'),
         },
-    },
-];
-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}`);
-    }
+    }, async (args) => {
+        await client.request('DELETE', `/pub/v1/calendar/events/${encodeURIComponent(args.eventId)}`);
+        return { content: [{ type: 'text', text: `Event ${args.eventId} deleted` }] };
+    });
 }

package/dist/tools/expenses.js

@@ -1,55 +1,34 @@
-export const toolDefinitions = [
-    {
-        name: 'ofw_get_expense_totals',
+import { z } from 'zod';
+export function registerExpenseTools(server, client) {
+    server.registerTool('ofw_get_expense_totals', {
         description: 'Get OurFamilyWizard expense summary totals (owed/paid)',
         annotations: { readOnlyHint: true },
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'ofw_list_expenses',
+    }, async () => {
+        const data = await client.request('GET', '/pub/v2/expense/expenses/totals');
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('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: [],
+            start: z.number().describe('Start offset (default 0)').optional(),
+            max: z.number().describe('Max results (default 20)').optional(),
         },
-    },
-    {
-        name: 'ofw_create_expense',
+    }, async (args) => {
+        const start = args.start ?? 0;
+        const max = args.max ?? 20;
+        const data = await client.request('GET', `/pub/v2/expense/expenses?start=${start}&max=${max}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('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'],
+            amount: z.number().describe('Expense amount'),
+            description: z.string().describe('Expense 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}`);
-    }
+    }, async (args) => {
+        const data = await client.request('POST', '/pub/v2/expense/expenses', args);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
 }

package/dist/tools/journal.js

@@ -1,46 +1,28 @@
-export const toolDefinitions = [
-    {
-        name: 'ofw_list_journal_entries',
+import { z } from 'zod';
+export function registerJournalTools(server, client) {
+    server.registerTool('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: [],
+            start: z.number().describe('Start offset (default 1)').optional(),
+            max: z.number().describe('Max results (default 10)').optional(),
         },
-    },
-    {
-        name: 'ofw_create_journal_entry',
+    }, async (args) => {
+        // Journal API uses 1-based offset (unlike expenses which start at 0)
+        const start = args.start ?? 1;
+        const max = args.max ?? 10;
+        const data = await client.request('GET', `/pub/v1/journals?start=${start}&max=${max}`);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('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'],
+            title: z.string().describe('Entry title'),
+            body: z.string().describe('Entry text content'),
         },
-    },
-];
-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}`);
-    }
+    }, async (args) => {
+        const data = await client.request('POST', '/pub/v1/journals', args);
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
 }