kakeibo-mcp-server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kakeibo
+
+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,190 @@
+# Kakeibo MCP Server
+
+Read-only MCP server for connecting AI clients to the Kakeibo Public Developer API.
+
+Phase 1 exposes personal `me` scope tools only. It can inspect profile, usage, currencies,
+accounts, categories, tags, transactions, and reports. It does not create, update, void, delete,
+upload, or otherwise mutate Kakeibo data.
+
+This package is MIT licensed. The Kakeibo application, backend, and hosted services remain
+proprietary.
+
+## Requirements
+
+- Node.js 20+
+- A Kakeibo Solo or Family account
+- A Kakeibo Public API key created in the dashboard under Settings -> Developer
+- An MCP-compatible client that can launch local stdio servers
+
+Do not commit API keys. Pass them through environment variables or your local MCP client
+configuration.
+
+## Configuration
+
+| Variable | Description |
+|---|---|
+| `KAKEIBO_API_BASE_URL` | Kakeibo API origin, for example `https://api.kakei.io` |
+| `KAKEIBO_API_KEY` | Public API key from Settings -> Developer |
+
+For production use:
+
+```bash
+export KAKEIBO_API_BASE_URL="https://api.kakei.io"
+export KAKEIBO_API_KEY="kak_xxxxxxxxxxxxxxxxxxxxxxxx"
+```
+
+For local backend development, use your Laravel API origin, for example `http://localhost:8000`.
+Do not include `/api/public/v1`; the server adds that path internally.
+
+## Install with npx
+
+Most users should run the published npm package directly from their MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "kakeibo": {
+      "command": "npx",
+      "args": ["-y", "kakeibo-mcp-server"],
+      "env": {
+        "KAKEIBO_API_BASE_URL": "https://api.kakei.io",
+        "KAKEIBO_API_KEY": "kak_xxxxxxxxxxxxxxxxxxxxxxxx"
+      }
+    }
+  }
+}
+```
+
+Restart your MCP client after updating its configuration.
+
+## Local Development
+
+Install dependencies from the repository root:
+
+```bash
+pnpm install
+```
+
+Run typecheck, build, and tests:
+
+```bash
+pnpm --filter kakeibo-mcp-server typecheck
+pnpm --filter kakeibo-mcp-server build
+pnpm --filter kakeibo-mcp-server test
+```
+
+Start the server in development mode:
+
+```bash
+KAKEIBO_API_BASE_URL="http://localhost:8000" \
+KAKEIBO_API_KEY="your-public-api-key" \
+pnpm --filter kakeibo-mcp-server dev
+```
+
+Build and run the compiled server:
+
+```bash
+pnpm --filter kakeibo-mcp-server build
+
+KAKEIBO_API_BASE_URL="http://localhost:8000" \
+KAKEIBO_API_KEY="your-public-api-key" \
+pnpm --filter kakeibo-mcp-server start
+```
+
+## Local MCP Client Configuration
+
+When developing from a local checkout, point your MCP client at the built server entrypoint:
+
+```json
+{
+  "mcpServers": {
+    "kakeibo": {
+      "command": "node",
+      "args": ["/absolute/path/to/kakeibo/apps/mcp-server/dist/index.js"],
+      "env": {
+        "KAKEIBO_API_BASE_URL": "http://localhost:8000",
+        "KAKEIBO_API_KEY": "your-public-api-key"
+      }
+    }
+  }
+}
+```
+
+Use an absolute path for `dist/index.js`. Rebuild after code changes.
+
+## Publishing
+
+Run these checks before publishing:
+
+```bash
+pnpm --filter kakeibo-mcp-server typecheck
+pnpm --filter kakeibo-mcp-server build
+pnpm --filter kakeibo-mcp-server test
+pnpm --filter kakeibo-mcp-server exec npm pack --dry-run
+```
+
+Publish from the package directory after confirming the packed files:
+
+```bash
+cd apps/mcp-server
+npm publish --access public
+```
+
+## Tools
+
+| Tool | Purpose |
+|---|---|
+| `get_current_user` | Get user profile and plan context |
+| `get_usage` | Inspect plan usage and quotas |
+| `list_currencies` | List supported currencies |
+| `list_accounts` | List accounts and balances |
+| `list_categories` | List transaction categories |
+| `list_tags` | List transaction tags |
+| `search_transactions` | Search and filter transactions |
+| `get_transaction` | Fetch a transaction by id |
+| `get_total_spending_report` | Get income, expense, and net totals |
+| `get_categories_spending_report` | Get spending grouped by category |
+| `get_spending_trends` | Get spending trend time series |
+| `get_dashboard_report` | Get combined report data |
+
+Report tools return Kakeibo Public API output as-is. Multi-currency totals may be limited while
+`converted_amount = amount` in the backend.
+
+## Example Prompts
+
+- Show my spending by category this month.
+- Find my largest expenses this year.
+- List my recent transactions for the default account.
+- How close am I to my plan limits?
+- Summarize my income and expenses for last month.
+
+## Smoke Test
+
+1. Start the Laravel API locally and confirm the Public Developer API is reachable.
+2. Create a Public API key in Settings -> Developer.
+3. Build this package with `pnpm --filter kakeibo-mcp-server build`.
+4. Configure an MCP client with the stdio command shown above.
+5. Ask for profile, reference data, transaction search, and a report.
+
+You can also run the built-in smoke script:
+
+```bash
+KAKEIBO_API_BASE_URL="http://localhost:8000" \
+KAKEIBO_API_KEY="your-public-api-key" \
+pnpm --filter kakeibo-mcp-server smoke
+```
+
+Minimum tools to verify:
+
+| Area | Tool |
+|---|---|
+| Profile | `get_current_user` |
+| Reference data | `list_accounts` |
+| Transactions | `search_transactions` |
+| Reports | `get_dashboard_report` |
+
+## Phase 2
+
+Mutation tools are planned separately. They will require stricter confirmation behavior and should
+not be added to Phase 1. Candidate future tools include transaction creation, transaction voiding,
+account lifecycle changes, category/tag management, and file attachment operations.

package/dist/config.js

@@ -0,0 +1,22 @@
+const normalizeBaseUrl = (value) => value.replace(/\/+$/, '');
+export const loadConfig = (env = process.env) => {
+    const apiBaseUrl = env.KAKEIBO_API_BASE_URL?.trim();
+    const apiKey = env.KAKEIBO_API_KEY?.trim();
+    const missing = [];
+    if (!apiBaseUrl) {
+        missing.push('KAKEIBO_API_BASE_URL');
+    }
+    if (!apiKey) {
+        missing.push('KAKEIBO_API_KEY');
+    }
+    if (missing.length > 0) {
+        throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
+    }
+    if (!apiBaseUrl || !apiKey) {
+        throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
+    }
+    return {
+        apiBaseUrl: normalizeBaseUrl(apiBaseUrl),
+        apiKey,
+    };
+};

package/dist/errors.js

@@ -0,0 +1,37 @@
+export class KakeiboApiError extends Error {
+    status;
+    validationErrors;
+    constructor(status, message, validationErrors) {
+        super(message);
+        this.name = 'KakeiboApiError';
+        this.status = status;
+        this.validationErrors = validationErrors;
+    }
+}
+export const statusToMessage = (status) => {
+    if (status === 401) {
+        return 'Invalid or missing Kakeibo API key.';
+    }
+    if (status === 402) {
+        return 'The current Kakeibo plan does not allow Public API access.';
+    }
+    if (status === 403) {
+        return 'The Kakeibo API key is not allowed to access this resource.';
+    }
+    if (status === 404) {
+        return 'The requested Kakeibo resource was not found.';
+    }
+    if (status === 409) {
+        return 'The request conflicts with Kakeibo business rules.';
+    }
+    if (status === 422) {
+        return 'The request contains invalid Kakeibo API parameters.';
+    }
+    if (status === 429) {
+        return 'Kakeibo Public API rate limit exceeded.';
+    }
+    if (status >= 500) {
+        return 'Kakeibo Public API returned an upstream server error.';
+    }
+    return `Kakeibo Public API request failed with status ${status}.`;
+};

package/dist/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { loadConfig } from './config.js';
+import { KakeiboClient } from './kakeibo-client.js';
+import { buildReadOnlyTools, registerTools } from './tools/index.js';
+const main = async () => {
+    const config = loadConfig();
+    const server = new McpServer({
+        name: 'kakeibo',
+        version: '0.1.0',
+    });
+    const client = new KakeiboClient(config);
+    registerTools(server, buildReadOnlyTools(client));
+    await server.connect(new StdioServerTransport());
+};
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : 'Unknown MCP server startup error';
+    console.error(`Kakeibo MCP server failed to start: ${message}`);
+    process.exitCode = 1;
+});

package/dist/kakeibo-client.js

@@ -0,0 +1,111 @@
+import { KakeiboApiError, statusToMessage } from './errors.js';
+export class KakeiboClient {
+    apiBaseUrl;
+    apiKey;
+    fetchFn;
+    constructor(config, fetchFn = fetch) {
+        this.apiBaseUrl = config.apiBaseUrl;
+        this.apiKey = config.apiKey;
+        this.fetchFn = fetchFn;
+    }
+    getCurrentUser() {
+        return this.get('/api/public/v1/me');
+    }
+    getUsage() {
+        return this.get('/api/public/v1/me/usage');
+    }
+    listCurrencies() {
+        return this.get('/api/public/v1/currencies');
+    }
+    listAccounts() {
+        return this.get('/api/public/v1/me/accounts');
+    }
+    listCategories() {
+        return this.get('/api/public/v1/me/categories');
+    }
+    listTags() {
+        return this.get('/api/public/v1/me/tags');
+    }
+    searchTransactions(params = {}) {
+        return this.get('/api/public/v1/me/transactions', params);
+    }
+    getTransaction(transactionId) {
+        return this.get(`/api/public/v1/me/transactions/${encodeURIComponent(transactionId)}`);
+    }
+    getTotalSpendingReport(params) {
+        return this.get('/api/public/v1/me/reports/total-spending', params);
+    }
+    getCategoriesSpendingReport(params) {
+        return this.get('/api/public/v1/me/reports/categories-spending', params);
+    }
+    getSpendingTrends(params) {
+        return this.get('/api/public/v1/me/reports/spending-trends', params);
+    }
+    getDashboardReport(params) {
+        return this.get('/api/public/v1/me/reports/dashboard', params);
+    }
+    async get(path, query = {}) {
+        const response = await this.fetchFn(this.buildUrl(path, query), {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        const body = await this.parseJson(response);
+        if (!response.ok) {
+            throw this.toApiError(response.status, body);
+        }
+        return body;
+    }
+    buildUrl(path, query) {
+        const url = new URL(path, `${this.apiBaseUrl}/`);
+        Object.entries(query).forEach(([key, value]) => {
+            if (value === undefined || value === null || value === '') {
+                return;
+            }
+            url.searchParams.set(key, String(value));
+        });
+        return url.toString();
+    }
+    async parseJson(response) {
+        const text = await response.text();
+        if (!text) {
+            return null;
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    toApiError(status, body) {
+        const errorBody = this.asErrorBody(body);
+        const upstreamMessage = this.extractMessage(errorBody);
+        const fallbackMessage = statusToMessage(status);
+        const message = upstreamMessage ? `${fallbackMessage} ${upstreamMessage}` : fallbackMessage;
+        const validationErrors = this.extractValidationErrors(errorBody);
+        return new KakeiboApiError(status, message, validationErrors);
+    }
+    asErrorBody(body) {
+        if (!body || typeof body !== 'object') {
+            return null;
+        }
+        return body;
+    }
+    extractMessage(body) {
+        if (!body) {
+            return null;
+        }
+        const candidates = [body.meta?.message, body.error?.message, body.message];
+        const message = candidates.find((candidate) => typeof candidate === 'string' && candidate);
+        return typeof message === 'string' ? message : null;
+    }
+    extractValidationErrors(body) {
+        if (!body || !body.errors || typeof body.errors !== 'object') {
+            return undefined;
+        }
+        return body.errors;
+    }
+}

package/dist/smoke.js

@@ -0,0 +1,23 @@
+import { loadConfig } from './config.js';
+import { KakeiboClient } from './kakeibo-client.js';
+import { buildReadOnlyTools } from './tools/index.js';
+const requiredTools = ['get_current_user', 'list_accounts', 'search_transactions', 'get_dashboard_report'];
+const main = async () => {
+    const client = new KakeiboClient(loadConfig());
+    const tools = buildReadOnlyTools(client);
+    for (const toolName of requiredTools) {
+        const tool = tools.find((candidate) => candidate.name === toolName);
+        if (!tool) {
+            throw new Error(`Missing smoke-test tool: ${toolName}`);
+        }
+        const args = toolName === 'search_transactions' ? { limit: 1 } : toolName === 'get_dashboard_report' ? { time_range: 'this_month' } : {};
+        const result = await tool.handler(args);
+        const text = result.content[0]?.text ?? '';
+        console.error(`Smoke test passed: ${toolName} returned ${text.length} characters.`);
+    }
+};
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : 'Unknown smoke test error';
+    console.error(`Kakeibo MCP smoke test failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/tools/accounts.js

@@ -0,0 +1,13 @@
+import { publicApiContent } from './tool-definition.js';
+import { emptySchema } from './schemas.js';
+export const accountTools = (client) => [
+    {
+        name: 'list_accounts',
+        description: 'List Kakeibo financial accounts and balances for the authenticated user.',
+        schema: emptySchema,
+        handler: async (args) => {
+            emptySchema.parse(args);
+            return publicApiContent(await client.listAccounts());
+        },
+    },
+];

package/dist/tools/categories.js

@@ -0,0 +1,13 @@
+import { publicApiContent } from './tool-definition.js';
+import { emptySchema } from './schemas.js';
+export const categoryTools = (client) => [
+    {
+        name: 'list_categories',
+        description: 'List Kakeibo transaction categories for the authenticated user.',
+        schema: emptySchema,
+        handler: async (args) => {
+            emptySchema.parse(args);
+            return publicApiContent(await client.listCategories());
+        },
+    },
+];

package/dist/tools/currencies.js

@@ -0,0 +1,13 @@
+import { publicApiContent } from './tool-definition.js';
+import { emptySchema } from './schemas.js';
+export const currencyTools = (client) => [
+    {
+        name: 'list_currencies',
+        description: 'List global currencies supported by Kakeibo.',
+        schema: emptySchema,
+        handler: async (args) => {
+            emptySchema.parse(args);
+            return publicApiContent(await client.listCurrencies());
+        },
+    },
+];

package/dist/tools/index.js

@@ -0,0 +1,17 @@
+import { accountTools } from './accounts.js';
+import { categoryTools } from './categories.js';
+import { currencyTools } from './currencies.js';
+import { meTools } from './me.js';
+import { reportTools } from './reports.js';
+import { tagTools } from './tags.js';
+import { transactionTools } from './transactions.js';
+export { registerTools } from './tool-definition.js';
+export const buildReadOnlyTools = (client) => [
+    ...meTools(client),
+    ...currencyTools(client),
+    ...accountTools(client),
+    ...categoryTools(client),
+    ...tagTools(client),
+    ...transactionTools(client),
+    ...reportTools(client),
+];

package/dist/tools/me.js

@@ -0,0 +1,22 @@
+import { publicApiContent } from './tool-definition.js';
+import { emptySchema } from './schemas.js';
+export const meTools = (client) => [
+    {
+        name: 'get_current_user',
+        description: 'Get the authenticated Kakeibo user profile and plan context.',
+        schema: emptySchema,
+        handler: async (args) => {
+            emptySchema.parse(args);
+            return publicApiContent(await client.getCurrentUser());
+        },
+    },
+    {
+        name: 'get_usage',
+        description: 'Inspect Kakeibo plan usage and quota information for the authenticated user.',
+        schema: emptySchema,
+        handler: async (args) => {
+            emptySchema.parse(args);
+            return publicApiContent(await client.getUsage());
+        },
+    },
+];

package/dist/tools/reports.js

@@ -0,0 +1,41 @@
+import { publicApiContent } from './tool-definition.js';
+import { reportSchema, spendingTrendsSchema } from './schemas.js';
+const multiCurrencyNote = 'Report totals use Kakeibo Public API output as-is. Multi-currency totals may be limited while converted_amount equals amount.';
+export const reportTools = (client) => [
+    {
+        name: 'get_total_spending_report',
+        description: `Get Kakeibo income, expense, and net totals for a period. ${multiCurrencyNote}`,
+        schema: reportSchema,
+        handler: async (args) => {
+            const params = reportSchema.parse(args);
+            return publicApiContent(await client.getTotalSpendingReport(params), [multiCurrencyNote]);
+        },
+    },
+    {
+        name: 'get_categories_spending_report',
+        description: `Get Kakeibo spending grouped by category for a period. ${multiCurrencyNote}`,
+        schema: reportSchema,
+        handler: async (args) => {
+            const params = reportSchema.parse(args);
+            return publicApiContent(await client.getCategoriesSpendingReport(params), [multiCurrencyNote]);
+        },
+    },
+    {
+        name: 'get_spending_trends',
+        description: `Get Kakeibo spending trend time series for a period. ${multiCurrencyNote}`,
+        schema: spendingTrendsSchema,
+        handler: async (args) => {
+            const params = spendingTrendsSchema.parse(args);
+            return publicApiContent(await client.getSpendingTrends(params), [multiCurrencyNote]);
+        },
+    },
+    {
+        name: 'get_dashboard_report',
+        description: `Get combined Kakeibo dashboard report data for an overview answer. ${multiCurrencyNote}`,
+        schema: reportSchema,
+        handler: async (args) => {
+            const params = reportSchema.parse(args);
+            return publicApiContent(await client.getDashboardReport(params), [multiCurrencyNote]);
+        },
+    },
+];

package/dist/tools/schemas.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export const emptySchema = z.object({});
+export const idSchema = z.object({
+    id: z.string().min(1),
+});
+export const transactionSearchSchema = z.object({
+    account_id: z.number().int().positive().optional(),
+    category_id: z.number().int().positive().optional(),
+    type: z.enum(['income', 'expense']).optional(),
+    search: z.string().min(1).optional(),
+    sort_by: z.enum(['amount', 'transaction_at']).optional(),
+    sort_order: z.enum(['asc', 'desc']).optional(),
+    limit: z.number().int().positive().max(100).default(20),
+    page: z.number().int().positive().default(1),
+    include_voided: z.boolean().default(false),
+});
+export const reportSchema = z
+    .object({
+    time_range: z.enum(['this_week', 'this_month', 'last_month', 'this_quarter', 'this_year', 'custom']),
+    start_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+    end_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+})
+    .refine((value) => value.time_range !== 'custom' || (value.start_date && value.end_date), {
+    message: 'start_date and end_date are required when time_range is custom.',
+    path: ['start_date'],
+});
+export const spendingTrendsSchema = reportSchema.extend({
+    group_by: z.enum(['day', 'week', 'month']).default('day'),
+});

package/dist/tools/tags.js

@@ -0,0 +1,13 @@
+import { publicApiContent } from './tool-definition.js';
+import { emptySchema } from './schemas.js';
+export const tagTools = (client) => [
+    {
+        name: 'list_tags',
+        description: 'List Kakeibo transaction tags for the authenticated user.',
+        schema: emptySchema,
+        handler: async (args) => {
+            emptySchema.parse(args);
+            return publicApiContent(await client.listTags());
+        },
+    },
+];

package/dist/tools/tool-definition.js

@@ -0,0 +1,39 @@
+export const jsonContent = (payload) => ({
+    content: [
+        {
+            type: 'text',
+            text: JSON.stringify(payload, null, 2),
+        },
+    ],
+});
+export const publicApiContent = (payload, notes = []) => {
+    const shapedPayload = shapePublicApiPayload(payload, notes);
+    return jsonContent(shapedPayload);
+};
+const shapePublicApiPayload = (payload, notes) => {
+    if (!payload || typeof payload !== 'object') {
+        return notes.length > 0 ? { data: payload, notes } : payload;
+    }
+    const record = payload;
+    if (!('data' in record)) {
+        return notes.length > 0 ? { ...record, notes } : payload;
+    }
+    const shaped = {
+        data: record.data,
+    };
+    if ('meta' in record) {
+        shaped.meta = record.meta;
+    }
+    if (notes.length > 0) {
+        shaped.notes = notes;
+    }
+    return shaped;
+};
+export const registerTools = (server, tools) => {
+    tools.forEach((tool) => {
+        server.registerTool(tool.name, {
+            description: tool.description,
+            inputSchema: tool.schema.shape,
+        }, async (args) => tool.handler(args));
+    });
+};

package/dist/tools/transactions.js

@@ -0,0 +1,22 @@
+import { publicApiContent } from './tool-definition.js';
+import { idSchema, transactionSearchSchema } from './schemas.js';
+export const transactionTools = (client) => [
+    {
+        name: 'search_transactions',
+        description: 'Search Kakeibo transactions with optional filters, pagination, and sorting. Defaults hide voided transactions.',
+        schema: transactionSearchSchema,
+        handler: async (args) => {
+            const params = transactionSearchSchema.parse(args);
+            return publicApiContent(await client.searchTransactions(params));
+        },
+    },
+    {
+        name: 'get_transaction',
+        description: 'Fetch a single Kakeibo transaction by id.',
+        schema: idSchema,
+        handler: async (args) => {
+            const { id } = idSchema.parse(args);
+            return publicApiContent(await client.getTransaction(id));
+        },
+    },
+];

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "kakeibo-mcp-server",
+  "version": "0.1.0",
+  "description": "Read-only MCP server for connecting AI clients to the Kakeibo Public Developer API.",
+  "type": "module",
+  "bin": {
+    "kakeibo-mcp-server": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "kakeibo",
+    "kakei",
+    "mcp",
+    "model-context-protocol",
+    "personal-finance"
+  ],
+  "homepage": "https://kakei.io/developers#mcp-server",
+  "bugs": {
+    "url": "https://github.com/mrsuner/kakeibo/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mrsuner/kakeibo.git",
+    "directory": "apps/mcp-server"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests --exclude \"dist/**\"",
+    "smoke": "node dist/smoke.js",
+    "prepublishOnly": "npm run typecheck && npm run build && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.1.5"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15"
+  }
+}