whooing-mcp 0.1.0

package/.env.example

@@ -0,0 +1,8 @@
+# Whooing API credentials
+# Get these from https://whooing.com → Settings → API
+WHOOING_APP_ID=3
+WHOOING_TOKEN=your_token_here
+WHOOING_SIGNATURE=your_signature_here
+
+# Default section (가계부) ID
+WHOOING_SECTION_ID=your_section_id_here

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JM Jeong
+
+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,139 @@
+# whooing-mcp
+
+MCP server for [Whooing (후잉)](https://whooing.com) personal finance — read-only queries for spending, transactions, balance sheets, and accounts.
+
+## Setup
+
+### 1. Get API Credentials
+
+1. Go to [Whooing App Settings](https://whooing.com/#main/setting/app)
+2. Note your `app_id`, `token`, and `signature`
+3. Find your `section_id` from the API or URL
+
+### 2. Install
+
+```bash
+git clone https://github.com/jmjeong/whooing-mcp.git
+cd whooing-mcp
+npm install
+npm run build
+```
+
+### 3. Configure Environment
+
+```bash
+export WHOOING_APP_ID=3
+export WHOOING_TOKEN=your_token
+export WHOOING_SIGNATURE=your_signature
+export WHOOING_SECTION_ID=your_section_id
+```
+
+Or create a `.env` file (see `.env.example`).
+
+## Usage
+
+### stdio mode (Claude Code, Claude Desktop)
+
+```bash
+node dist/cli.js
+```
+
+### HTTP mode (daemon)
+
+```bash
+node dist/cli.js --http --port 8182
+```
+
+### Claude Code config (`~/.mcp.json`)
+
+```json
+{
+  "mcpServers": {
+    "whooing": {
+      "command": "node",
+      "args": ["/path/to/whooing-mcp/dist/cli.js"],
+      "env": {
+        "WHOOING_APP_ID": "3",
+        "WHOOING_TOKEN": "...",
+        "WHOOING_SIGNATURE": "...",
+        "WHOOING_SECTION_ID": "..."
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop config
+
+```json
+{
+  "mcpServers": {
+    "whooing": {
+      "command": "node",
+      "args": ["/path/to/whooing-mcp/dist/cli.js"],
+      "env": {
+        "WHOOING_APP_ID": "3",
+        "WHOOING_TOKEN": "...",
+        "WHOOING_SIGNATURE": "...",
+        "WHOOING_SECTION_ID": "..."
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description | Parameters |
+|------|-------------|------------|
+| `whooing_pl` | Profit & loss (spending/income by category) | `start_date?`, `end_date?`, `section_id?` |
+| `whooing_entries` | Transaction list with account names | `start_date?`, `end_date?`, `limit?`, `section_id?` |
+| `whooing_balance` | Balance sheet (assets, liabilities, capital) | `start_date?`, `end_date?`, `section_id?` |
+| `whooing_accounts` | Full account list | `section_id?` |
+| `whooing_sections` | List all sections (가계부) | (none) |
+
+- Dates use `YYYYMMDD` format. Default: current month (1st to today).
+- `section_id` defaults to `WHOOING_SECTION_ID` env var.
+- All tools are read-only.
+
+## Running as a daemon (macOS launchd)
+
+Create `~/Library/LaunchAgents/com.whooing.mcp.plist`:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key><string>com.whooing.mcp</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/opt/homebrew/bin/node</string>
+        <string>/path/to/whooing-mcp/dist/cli.js</string>
+        <string>--http</string>
+        <string>--port</string>
+        <string>8182</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>WHOOING_APP_ID</key><string>3</string>
+        <key>WHOOING_TOKEN</key><string>YOUR_TOKEN</string>
+        <key>WHOOING_SIGNATURE</key><string>YOUR_SIGNATURE</string>
+        <key>WHOOING_SECTION_ID</key><string>YOUR_SECTION_ID</string>
+    </dict>
+    <key>KeepAlive</key><true/>
+    <key>RunAtLoad</key><true/>
+    <key>StandardOutPath</key><string>/tmp/whooing-mcp.log</string>
+    <key>StandardErrorPath</key><string>/tmp/whooing-mcp.err</string>
+</dict>
+</plist>
+```
+
+```bash
+chmod 600 ~/Library/LaunchAgents/com.whooing.mcp.plist
+launchctl load ~/Library/LaunchAgents/com.whooing.mcp.plist
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+import dotenv from "dotenv";
+import { WhooingClient } from "./whooing-client.js";
+import { createWhooingMcpServer } from "./server.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "node:http";
+dotenv.config();
+function getRequiredEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        console.error(`Error: Missing required environment variable: ${name}`);
+        process.exit(1);
+    }
+    return value;
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let http = false;
+    let port = 8182;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--http") {
+            http = true;
+        }
+        else if (args[i] === "--port" && i + 1 < args.length) {
+            port = parseInt(args[i + 1], 10);
+            if (isNaN(port)) {
+                console.error(`Error: Invalid port number: ${args[i + 1]}`);
+                process.exit(1);
+            }
+            i++;
+        }
+    }
+    return { http, port };
+}
+function getConfig() {
+    return {
+        appId: getRequiredEnv("WHOOING_APP_ID"),
+        token: getRequiredEnv("WHOOING_TOKEN"),
+        signature: getRequiredEnv("WHOOING_SIGNATURE"),
+        defaultSectionId: process.env.WHOOING_SECTION_ID ?? "",
+    };
+}
+async function main() {
+    const config = getConfig();
+    const { http, port } = parseArgs();
+    if (http) {
+        await startHttpServer(config, port);
+    }
+    else {
+        const client = new WhooingClient(config);
+        if (config.defaultSectionId) {
+            try {
+                await client.loadAccounts(config.defaultSectionId);
+            }
+            catch (e) {
+                console.error("Warning: Failed to pre-load accounts:", e);
+            }
+        }
+        const server = createWhooingMcpServer(client);
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+    }
+}
+async function startHttpServer(config, port) {
+    const sessions = new Map();
+    function createSession() {
+        const client = new WhooingClient(config);
+        const server = createWhooingMcpServer(client);
+        return { server, client };
+    }
+    const httpServer = createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+        // Health check
+        if (url.pathname === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "ok" }));
+            return;
+        }
+        if (url.pathname === "/mcp") {
+            const sessionId = req.headers["mcp-session-id"];
+            try {
+                if (req.method === "POST") {
+                    const body = await collectBody(req);
+                    const parsed = JSON.parse(body);
+                    if (sessionId && sessions.has(sessionId)) {
+                        const entry = sessions.get(sessionId);
+                        await entry.transport.handleRequest(req, res, parsed);
+                    }
+                    else {
+                        // New session — create fresh server + transport
+                        const { server, client } = createSession();
+                        const transport = new StreamableHTTPServerTransport({
+                            sessionIdGenerator: () => crypto.randomUUID(),
+                        });
+                        transport.onclose = () => {
+                            if (transport.sessionId) {
+                                sessions.delete(transport.sessionId);
+                            }
+                        };
+                        await server.connect(transport);
+                        // Pre-load accounts in background (don't block the response)
+                        if (config.defaultSectionId) {
+                            client.loadAccounts(config.defaultSectionId).catch((e) => {
+                                console.error("Warning: Failed to pre-load accounts:", e);
+                            });
+                        }
+                        await transport.handleRequest(req, res, parsed);
+                        if (transport.sessionId) {
+                            sessions.set(transport.sessionId, { transport, server });
+                        }
+                    }
+                    return;
+                }
+                if (req.method === "GET") {
+                    if (sessionId && sessions.has(sessionId)) {
+                        const entry = sessions.get(sessionId);
+                        await entry.transport.handleRequest(req, res);
+                    }
+                    else {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "No valid session" }));
+                    }
+                    return;
+                }
+                if (req.method === "DELETE") {
+                    if (sessionId && sessions.has(sessionId)) {
+                        const entry = sessions.get(sessionId);
+                        await entry.transport.handleRequest(req, res);
+                        sessions.delete(sessionId);
+                    }
+                    else {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "No valid session" }));
+                    }
+                    return;
+                }
+            }
+            catch (err) {
+                console.error("Request error:", err);
+                if (!res.headersSent) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Internal server error" }));
+                }
+                return;
+            }
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+    });
+    httpServer.listen(port, "0.0.0.0", () => {
+        console.error(`whooing-mcp HTTP server listening on http://0.0.0.0:${port}/mcp`);
+        console.error(`Health check: http://localhost:${port}/health`);
+    });
+}
+function collectBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+        req.on("error", reject);
+    });
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/formatters.d.ts

@@ -0,0 +1,67 @@
+import type { AccountInfo } from "./whooing-client.js";
+interface AccountEntry {
+    account_id: string;
+    money: number;
+}
+interface CategoryGroup {
+    total: number;
+    accounts: AccountEntry[];
+}
+interface PLResults {
+    expenses?: CategoryGroup;
+    income?: CategoryGroup;
+    net_income?: {
+        total: number;
+    };
+}
+export declare function formatPL(results: PLResults, accounts: Map<string, AccountInfo>, startDate: string, endDate: string): string;
+interface EntryItem {
+    entry_id: number;
+    entry_date: string;
+    l_account: string;
+    l_account_id: string;
+    r_account: string;
+    r_account_id: string;
+    item: string;
+    money: number;
+    memo: string;
+}
+interface EntryResults {
+    rows?: EntryItem[];
+}
+export declare function formatEntries(results: EntryResults, accounts: Map<string, AccountInfo>): string;
+interface BSResults {
+    assets?: CategoryGroup;
+    liabilities?: CategoryGroup;
+    capital?: CategoryGroup;
+}
+export declare function formatBalance(results: BSResults, accounts: Map<string, AccountInfo>, startDate: string, endDate: string): string;
+interface BudgetItem {
+    account_id: string;
+    budget: number;
+    money: number;
+}
+type BudgetResults = {
+    expenses?: {
+        accounts: BudgetItem[];
+    };
+} | BudgetItem[];
+export declare function formatBudget(results: BudgetResults, accounts: Map<string, AccountInfo>, startDate: string, endDate: string): string;
+interface AccountItem {
+    account_id: string;
+    title: string;
+    type: string;
+    memo?: string;
+    open_date?: string;
+    close_date?: string;
+    category?: string;
+}
+export declare function formatAccounts(results: Record<string, AccountItem[]>): string;
+interface SectionItem {
+    section_id: string;
+    title: string;
+    memo?: string;
+    currency?: string;
+}
+export declare function formatSections(results: SectionItem[]): string;
+export {};

package/dist/formatters.js

@@ -0,0 +1,154 @@
+function formatAmount(amount) {
+    return amount.toLocaleString("ko-KR") + "원";
+}
+export function formatPL(results, accounts, startDate, endDate) {
+    const lines = [];
+    lines.push(`## 손익 (${startDate} ~ ${endDate})`);
+    lines.push("");
+    // Expenses
+    const expenseAccounts = (results.expenses?.accounts ?? [])
+        .filter((item) => item.money > 0)
+        .sort((a, b) => b.money - a.money);
+    if (expenseAccounts.length > 0) {
+        lines.push(`### 지출: ${formatAmount(results.expenses?.total ?? 0)}`);
+        for (const item of expenseAccounts) {
+            const name = accounts.get(item.account_id)?.name ?? item.account_id;
+            lines.push(`- ${name}: ${formatAmount(item.money)}`);
+        }
+        lines.push("");
+    }
+    // Income
+    const incomeAccounts = (results.income?.accounts ?? [])
+        .filter((item) => item.money > 0)
+        .sort((a, b) => b.money - a.money);
+    if (incomeAccounts.length > 0) {
+        lines.push(`### 수입: ${formatAmount(results.income?.total ?? 0)}`);
+        for (const item of incomeAccounts) {
+            const name = accounts.get(item.account_id)?.name ?? item.account_id;
+            lines.push(`- ${name}: ${formatAmount(item.money)}`);
+        }
+        lines.push("");
+    }
+    if (results.net_income) {
+        lines.push(`### 순이익: ${formatAmount(results.net_income.total)}`);
+    }
+    if (expenseAccounts.length === 0 && incomeAccounts.length === 0) {
+        lines.push("해당 기간에 데이터가 없습니다.");
+    }
+    return lines.join("\n");
+}
+export function formatEntries(results, accounts) {
+    const rows = results.rows ?? [];
+    if (rows.length === 0) {
+        return "해당 기간에 거래 내역이 없습니다.";
+    }
+    const lines = [];
+    lines.push(`## 거래 내역 (${rows.length}건)`);
+    lines.push("");
+    for (const row of rows) {
+        const date = formatDate(row.entry_date);
+        const lName = accounts.get(row.l_account_id)?.name ?? row.l_account_id;
+        const rName = accounts.get(row.r_account_id)?.name ?? row.r_account_id;
+        const item = row.item || "(항목 없음)";
+        const memo = row.memo ? ` — ${row.memo}` : "";
+        lines.push(`- **${date}** ${item} ${formatAmount(row.money)} [${lName} ← ${rName}]${memo}`);
+    }
+    return lines.join("\n");
+}
+function formatDate(dateStr) {
+    // Handle YYYYMMDD or YYYYMMDD.NNNN format
+    const base = dateStr.split(".")[0];
+    if (base.length === 8) {
+        return `${base.slice(0, 4)}-${base.slice(4, 6)}-${base.slice(6, 8)}`;
+    }
+    return dateStr;
+}
+export function formatBalance(results, accounts, startDate, endDate) {
+    const lines = [];
+    lines.push(`## 자산/부채 현황 (${startDate} ~ ${endDate})`);
+    lines.push("");
+    const sections = [
+        ["자산", results.assets],
+        ["부채", results.liabilities],
+        ["자본", results.capital],
+    ];
+    for (const [title, group] of sections) {
+        const filtered = (group?.accounts ?? [])
+            .filter((item) => item.money !== 0)
+            .sort((a, b) => Math.abs(b.money) - Math.abs(a.money));
+        if (filtered.length > 0) {
+            lines.push(`### ${title}: ${formatAmount(group?.total ?? 0)}`);
+            for (const item of filtered) {
+                const name = accounts.get(item.account_id)?.name ?? item.account_id;
+                lines.push(`- ${name}: ${formatAmount(item.money)}`);
+            }
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+export function formatBudget(results, accounts, startDate, endDate) {
+    const lines = [];
+    lines.push(`## 예산 현황 (${startDate} ~ ${endDate})`);
+    lines.push("");
+    let budgetItems = [];
+    if (Array.isArray(results)) {
+        // Empty array — no budgets
+    }
+    else if (results.expenses?.accounts) {
+        budgetItems = results.expenses.accounts;
+    }
+    const items = budgetItems
+        .filter((item) => item.budget > 0 || item.money > 0)
+        .sort((a, b) => b.money - a.money);
+    if (items.length === 0) {
+        lines.push("설정된 예산이 없습니다.");
+        return lines.join("\n");
+    }
+    for (const item of items) {
+        const name = accounts.get(item.account_id)?.name ?? item.account_id;
+        const pct = item.budget > 0 ? Math.round((item.money / item.budget) * 100) : 0;
+        const status = pct > 100 ? " (초과!)" : "";
+        lines.push(`- ${name}: ${formatAmount(item.money)} / ${formatAmount(item.budget)} (${pct}%)${status}`);
+    }
+    return lines.join("\n");
+}
+export function formatAccounts(results) {
+    const lines = [];
+    lines.push("## 계정 목록");
+    lines.push("");
+    const typeNames = {
+        assets: "자산",
+        liabilities: "부채",
+        capital: "자본",
+        income: "수입",
+        expenses: "지출",
+    };
+    for (const [type, accounts] of Object.entries(results)) {
+        if (!Array.isArray(accounts) || accounts.length === 0)
+            continue;
+        const typeName = typeNames[type] ?? type;
+        lines.push(`### ${typeName}`);
+        for (const acc of accounts) {
+            const memo = acc.memo ? ` (${acc.memo})` : "";
+            lines.push(`- ${acc.account_id}: ${acc.title}${memo}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export function formatSections(results) {
+    const lines = [];
+    lines.push("## 가계부 (Section) 목록");
+    lines.push("");
+    if (!Array.isArray(results) || results.length === 0) {
+        lines.push("가계부가 없습니다.");
+        return lines.join("\n");
+    }
+    for (const section of results) {
+        const currency = section.currency ? ` [${section.currency}]` : "";
+        const memo = section.memo ? ` — ${section.memo}` : "";
+        lines.push(`- ${section.section_id}: ${section.title}${currency}${memo}`);
+    }
+    return lines.join("\n");
+}

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { WhooingClient } from "./whooing-client.js";
+export declare function createWhooingMcpServer(client: WhooingClient): McpServer;

package/dist/server.js

@@ -0,0 +1,141 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { formatPL, formatEntries, formatBalance, formatAccounts, formatSections, } from "./formatters.js";
+function getDateDefaults() {
+    const now = new Date();
+    const y = now.getFullYear();
+    const m = String(now.getMonth() + 1).padStart(2, "0");
+    const d = String(now.getDate()).padStart(2, "0");
+    return {
+        startDate: `${y}${m}01`,
+        endDate: `${y}${m}${d}`,
+    };
+}
+const dateRangeSchema = {
+    start_date: z
+        .string()
+        .regex(/^\d{8}$/)
+        .optional()
+        .describe("Start date (YYYYMMDD). Defaults to 1st of current month."),
+    end_date: z
+        .string()
+        .regex(/^\d{8}$/)
+        .optional()
+        .describe("End date (YYYYMMDD). Defaults to today."),
+    section_id: z
+        .string()
+        .optional()
+        .describe("Section ID. Defaults to WHOOING_SECTION_ID env var."),
+};
+export function createWhooingMcpServer(client) {
+    const server = new McpServer({
+        name: "whooing-mcp",
+        version: "0.1.0",
+    }, {
+        instructions: "Whooing (후잉) is a Korean personal finance tracking service. " +
+            "This server provides read-only access to financial data: " +
+            "spending/income summaries (P&L), transaction lists, balance sheets, " +
+            "and account listings. " +
+            "Dates use YYYYMMDD format. All amounts are in KRW (원). " +
+            "If no dates are specified, the current month is used.",
+    });
+    // whooing_pl — Profit & Loss
+    server.registerTool("whooing_pl", {
+        description: "Get profit & loss summary (spending and income by category) for a date range",
+        inputSchema: dateRangeSchema,
+        annotations: { readOnlyHint: true },
+    }, async (args) => {
+        const defaults = getDateDefaults();
+        const startDate = args.start_date ?? defaults.startDate;
+        const endDate = args.end_date ?? defaults.endDate;
+        const sectionId = args.section_id ?? client.defaultSectionId;
+        await client.loadAccounts(sectionId);
+        const results = await client.apiGet("pl.json", {
+            section_id: sectionId,
+            start_date: startDate,
+            end_date: endDate,
+        });
+        const text = formatPL(results, client.getAccountCache(), startDate, endDate);
+        return { content: [{ type: "text", text }] };
+    });
+    // whooing_entries — Transaction list
+    server.registerTool("whooing_entries", {
+        description: "Get transaction entries (individual transactions with account names) for a date range",
+        inputSchema: {
+            ...dateRangeSchema,
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(500)
+                .optional()
+                .describe("Max number of entries to return. Defaults to 20."),
+        },
+        annotations: { readOnlyHint: true },
+    }, async (args) => {
+        const defaults = getDateDefaults();
+        const startDate = args.start_date ?? defaults.startDate;
+        const endDate = args.end_date ?? defaults.endDate;
+        const sectionId = args.section_id ?? client.defaultSectionId;
+        const limit = args.limit ?? 20;
+        await client.loadAccounts(sectionId);
+        const results = await client.apiGet("entries.json", {
+            section_id: sectionId,
+            start_date: startDate,
+            end_date: endDate,
+            limit: String(limit),
+        });
+        const text = formatEntries(results, client.getAccountCache());
+        return { content: [{ type: "text", text }] };
+    });
+    // whooing_balance — Balance sheet
+    server.registerTool("whooing_balance", {
+        description: "Get balance sheet (assets, liabilities, capital) as of a date range",
+        inputSchema: dateRangeSchema,
+        annotations: { readOnlyHint: true },
+    }, async (args) => {
+        const defaults = getDateDefaults();
+        const startDate = args.start_date ?? defaults.startDate;
+        const endDate = args.end_date ?? defaults.endDate;
+        const sectionId = args.section_id ?? client.defaultSectionId;
+        await client.loadAccounts(sectionId);
+        const results = await client.apiGet("bs.json", {
+            section_id: sectionId,
+            start_date: startDate,
+            end_date: endDate,
+        });
+        const text = formatBalance(results, client.getAccountCache(), startDate, endDate);
+        return { content: [{ type: "text", text }] };
+    });
+    // whooing_accounts — Account list
+    server.registerTool("whooing_accounts", {
+        description: "Get the full list of accounts (assets, liabilities, income, expenses, capital)",
+        inputSchema: {
+            section_id: z
+                .string()
+                .optional()
+                .describe("Section ID. Defaults to WHOOING_SECTION_ID env var."),
+        },
+        annotations: { readOnlyHint: true },
+    }, async (args) => {
+        const sectionId = args.section_id ?? client.defaultSectionId;
+        const results = await client.loadAccounts(sectionId);
+        // Re-fetch raw data for formatting
+        const raw = await client.apiGet("accounts.json", {
+            section_id: sectionId,
+        });
+        const text = formatAccounts(raw);
+        return { content: [{ type: "text", text }] };
+    });
+    // whooing_sections — List sections
+    server.registerTool("whooing_sections", {
+        description: "List all sections (가계부) in the Whooing account",
+        inputSchema: {},
+        annotations: { readOnlyHint: true },
+    }, async () => {
+        const results = await client.apiGet("sections.json");
+        const text = formatSections(results);
+        return { content: [{ type: "text", text }] };
+    });
+    return server;
+}

package/dist/whooing-client.d.ts

@@ -0,0 +1,22 @@
+export interface WhooingConfig {
+    appId: string;
+    token: string;
+    signature: string;
+    defaultSectionId: string;
+}
+export interface AccountInfo {
+    name: string;
+    type: string;
+}
+export declare class WhooingClient {
+    private config;
+    private accountCache;
+    constructor(config: WhooingConfig);
+    get defaultSectionId(): string;
+    private getApiKey;
+    apiGet(endpoint: string, params?: Record<string, string>): Promise<unknown>;
+    loadAccounts(sectionId?: string): Promise<Map<string, AccountInfo>>;
+    getAccountName(accountId: string): string;
+    getAccountInfo(accountId: string): AccountInfo | undefined;
+    getAccountCache(): Map<string, AccountInfo>;
+}

package/dist/whooing-client.js

@@ -0,0 +1,65 @@
+import crypto from "node:crypto";
+export class WhooingClient {
+    config;
+    accountCache = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    get defaultSectionId() {
+        return this.config.defaultSectionId;
+    }
+    getApiKey() {
+        const nounce = crypto.randomBytes(20).toString("hex");
+        const timestamp = Math.floor(Date.now() / 1000);
+        return `app_id=${this.config.appId},token=${this.config.token},signiture=${this.config.signature},nounce=${nounce},timestamp=${timestamp}`;
+    }
+    async apiGet(endpoint, params = {}) {
+        const qs = new URLSearchParams(params).toString();
+        const url = qs
+            ? `https://whooing.com/api/${endpoint}?${qs}`
+            : `https://whooing.com/api/${endpoint}`;
+        const res = await fetch(url, {
+            method: "GET",
+            headers: {
+                "X-API-KEY": this.getApiKey(),
+            },
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Whooing API error ${res.status}: ${text}`);
+        }
+        const json = (await res.json());
+        if (json.code !== 200) {
+            throw new Error(`Whooing API error ${json.code}: ${json.message}`);
+        }
+        return json.results;
+    }
+    async loadAccounts(sectionId) {
+        const sid = sectionId || this.config.defaultSectionId;
+        const results = (await this.apiGet("accounts.json", {
+            section_id: sid,
+        }));
+        const cache = new Map();
+        for (const [type, accounts] of Object.entries(results)) {
+            if (!Array.isArray(accounts))
+                continue;
+            for (const acc of accounts) {
+                cache.set(acc.account_id, { name: acc.title, type });
+            }
+        }
+        // Merge into main cache
+        for (const [id, info] of cache) {
+            this.accountCache.set(id, info);
+        }
+        return cache;
+    }
+    getAccountName(accountId) {
+        return this.accountCache.get(accountId)?.name ?? accountId;
+    }
+    getAccountInfo(accountId) {
+        return this.accountCache.get(accountId);
+    }
+    getAccountCache() {
+        return this.accountCache;
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "whooing-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Whooing (후잉) personal finance — read-only queries for spending, transactions, budgets, and balance sheets",
+  "type": "module",
+  "main": "./dist/server.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "mcp",
+    "whooing",
+    "후잉",
+    "가계부",
+    "finance",
+    "model-context-protocol"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^3.23.0",
+    "dotenv": "^16.4.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.0",
+    "@types/node": "^22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jmjeong/whooing-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jmjeong/whooing-mcp/issues"
+  },
+  "homepage": "https://github.com/jmjeong/whooing-mcp#readme",
+  "bin": {
+    "whooing-mcp": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ]
+}