cc-usage-mcp 1.0.0

package/README.md

@@ -0,0 +1,61 @@
+# cc-usage-mcp
+
+Claude Code 用量追踪 MCP 服务器，支持 Windows / macOS / Linux。
+
+解析本地 `~/.claude/projects/` 下的 JSONL 会话文件，统计 token 用量和费用。
+
+## 功能
+
+- `usage_summary` - 按项目/模型/日期汇总用量和费用，支持时间范围筛选
+- `usage_today` - 查看今日用量
+- `usage_session` - 查看指定会话或最近会话的用量
+- `usage_cost_estimate` - 估算指定 token 数量的费用
+
+## 安装
+
+```bash
+npm install
+npm run build
+```
+
+## 配置
+
+在 Claude Code 的 MCP 设置中添加：
+
+### 方式一：项目级配置 (.claude/settings.json)
+
+```json
+{
+  "mcpServers": {
+    "cc-usage": {
+      "command": "node",
+      "args": ["d:/temp/ikun-cc-usage-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+### 方式二：全局配置 (~/.claude/settings.json)
+
+```json
+{
+  "mcpServers": {
+    "cc-usage": {
+      "command": "node",
+      "args": ["/path/to/cc-usage-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+路径根据你的系统调整：
+- Windows: `"d:/temp/ikun-cc-usage-mcp/dist/index.js"`
+- macOS/Linux: `"/home/user/cc-usage-mcp/dist/index.js"`
+
+## 支持的模型计价
+
+| 模型 | Input | Output | Cache Write | Cache Read |
+|------|-------|--------|-------------|------------|
+| claude-opus-4-6 | $15/M | $75/M | $18.75/M | $1.5/M |
+| claude-sonnet-4-6 | $3/M | $15/M | $3.75/M | $0.3/M |
+| claude-haiku-4-5 | $0.8/M | $4/M | $1/M | $0.08/M |

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const parser_1 = require("./parser");
+const server = new mcp_js_1.McpServer({
+    name: "cc-usage-mcp",
+    version: "1.0.0",
+});
+function formatTokens(n) {
+    if (n >= 1000000)
+        return `${(n / 1000000).toFixed(2)}M`;
+    if (n >= 1000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return String(n);
+}
+function formatCost(cost) {
+    return `$${cost.toFixed(4)}`;
+}
+function formatUsageBlock(usage) {
+    return [
+        `  Input:       ${formatTokens(usage.inputTokens)}`,
+        `  Output:      ${formatTokens(usage.outputTokens)}`,
+        `  Cache Write: ${formatTokens(usage.cacheWriteTokens)}`,
+        `  Cache Read:  ${formatTokens(usage.cacheReadTokens)}`,
+    ].join("\n");
+}
+server.tool("usage_summary", "Get Claude Code usage summary with cost breakdown by project, model, and date", {
+    startDate: zod_1.z.string().optional().describe("Start date filter (YYYY-MM-DD)"),
+    endDate: zod_1.z.string().optional().describe("End date filter (YYYY-MM-DD)"),
+    project: zod_1.z.string().optional().describe("Filter by project name (partial match)"),
+    groupBy: zod_1.z
+        .enum(["project", "model", "date", "all"])
+        .default("all")
+        .describe("Group results by category"),
+}, async ({ startDate, endDate, project, groupBy }) => {
+    const summary = await (0, parser_1.getUsageSummary)(startDate, endDate, project);
+    const lines = [];
+    lines.push("=== Claude Code Usage Summary ===");
+    lines.push("");
+    lines.push(`Total Cost: ${formatCost(summary.totalCost)}`);
+    lines.push(`Sessions:   ${summary.sessions.length}`);
+    lines.push("");
+    lines.push("Total Tokens:");
+    lines.push(formatUsageBlock(summary.totalUsage));
+    if (groupBy === "project" || groupBy === "all") {
+        lines.push("");
+        lines.push("--- By Project ---");
+        const sorted = Object.entries(summary.byProject).sort((a, b) => b[1].cost - a[1].cost);
+        for (const [proj, data] of sorted) {
+            lines.push(`  ${proj}: ${formatCost(data.cost)}`);
+        }
+    }
+    if (groupBy === "model" || groupBy === "all") {
+        lines.push("");
+        lines.push("--- By Model ---");
+        const sorted = Object.entries(summary.byModel).sort((a, b) => b[1].cost - a[1].cost);
+        for (const [model, data] of sorted) {
+            lines.push(`  ${model}: ${formatCost(data.cost)}`);
+        }
+    }
+    if (groupBy === "date" || groupBy === "all") {
+        lines.push("");
+        lines.push("--- By Date ---");
+        const sorted = Object.entries(summary.byDate).sort((a, b) => b[0].localeCompare(a[0]));
+        for (const [date, data] of sorted.slice(0, 30)) {
+            lines.push(`  ${date}: ${formatCost(data.cost)}`);
+        }
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+});
+server.tool("usage_today", "Get today's Claude Code usage and cost", {}, async () => {
+    const today = new Date().toISOString().split("T")[0];
+    const summary = await (0, parser_1.getUsageSummary)(today, today);
+    const lines = [];
+    lines.push(`=== Today's Usage (${today}) ===`);
+    lines.push("");
+    lines.push(`Cost:     ${formatCost(summary.totalCost)}`);
+    lines.push(`Sessions: ${summary.sessions.length}`);
+    lines.push("");
+    lines.push("Tokens:");
+    lines.push(formatUsageBlock(summary.totalUsage));
+    if (Object.keys(summary.byModel).length > 0) {
+        lines.push("");
+        lines.push("By Model:");
+        for (const [model, data] of Object.entries(summary.byModel)) {
+            lines.push(`  ${model}: ${formatCost(data.cost)}`);
+        }
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+});
+server.tool("usage_session", "Get usage for a specific session or the most recent session", {
+    sessionId: zod_1.z.string().optional().describe("Session ID (defaults to most recent)"),
+}, async ({ sessionId }) => {
+    if (sessionId) {
+        const session = await (0, parser_1.getCurrentSessionUsage)(sessionId);
+        if (!session) {
+            return { content: [{ type: "text", text: "Session not found." }] };
+        }
+        const lines = [
+            `=== Session: ${session.sessionId} ===`,
+            "",
+            `Project:  ${session.project}`,
+            `Model:    ${session.model}`,
+            `Cost:     ${formatCost(session.cost)}`,
+            `Messages: ${session.messageCount}`,
+            `Start:    ${session.startTime}`,
+            `End:      ${session.endTime}`,
+            "",
+            "Tokens:",
+            formatUsageBlock(session.usage),
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    const summary = await (0, parser_1.getUsageSummary)();
+    const sorted = summary.sessions.sort((a, b) => {
+        if (!a.endTime || !b.endTime)
+            return 0;
+        return b.endTime.localeCompare(a.endTime);
+    });
+    if (sorted.length === 0) {
+        return { content: [{ type: "text", text: "No sessions found." }] };
+    }
+    const recent = sorted.slice(0, 5);
+    const lines = ["=== Recent Sessions ===", ""];
+    for (const s of recent) {
+        lines.push(`${s.sessionId.slice(0, 8)}... | ${s.project} | ${s.model} | ${formatCost(s.cost)} | ${s.messageCount} msgs`);
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+});
+server.tool("usage_cost_estimate", "Estimate cost for a given number of tokens", {
+    model: zod_1.z.string().default("claude-sonnet-4-6").describe("Model name"),
+    inputTokens: zod_1.z.number().default(0).describe("Number of input tokens"),
+    outputTokens: zod_1.z.number().default(0).describe("Number of output tokens"),
+    cacheWriteTokens: zod_1.z.number().default(0).describe("Number of cache write tokens"),
+    cacheReadTokens: zod_1.z.number().default(0).describe("Number of cache read tokens"),
+}, async ({ model, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens }) => {
+    const { calculateCost, getPricing } = await Promise.resolve().then(() => __importStar(require("./pricing")));
+    const pricing = getPricing(model);
+    const cost = calculateCost(model, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens);
+    const lines = [
+        `=== Cost Estimate (${model}) ===`,
+        "",
+        `Pricing:`,
+        `  Input:       $${pricing.inputPerMillion}/M tokens`,
+        `  Output:      $${pricing.outputPerMillion}/M tokens`,
+        `  Cache Write: $${pricing.cacheWritePerMillion}/M tokens`,
+        `  Cache Read:  $${pricing.cacheReadPerMillion}/M tokens`,
+        "",
+        `Tokens:`,
+        `  Input:       ${formatTokens(inputTokens)}`,
+        `  Output:      ${formatTokens(outputTokens)}`,
+        `  Cache Write: ${formatTokens(cacheWriteTokens)}`,
+        `  Cache Read:  ${formatTokens(cacheReadTokens)}`,
+        "",
+        `Estimated Cost: ${formatCost(cost)}`,
+    ];
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+});
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/dist/parser.d.ts

@@ -0,0 +1,36 @@
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheWriteTokens: number;
+    cacheReadTokens: number;
+}
+export interface SessionSummary {
+    sessionId: string;
+    project: string;
+    model: string;
+    usage: TokenUsage;
+    cost: number;
+    startTime: string;
+    endTime: string;
+    messageCount: number;
+}
+export interface UsageSummary {
+    totalCost: number;
+    totalUsage: TokenUsage;
+    byProject: Record<string, {
+        cost: number;
+        usage: TokenUsage;
+    }>;
+    byModel: Record<string, {
+        cost: number;
+        usage: TokenUsage;
+    }>;
+    byDate: Record<string, {
+        cost: number;
+        usage: TokenUsage;
+    }>;
+    sessions: SessionSummary[];
+}
+export declare function getUsageSummary(startDate?: string, endDate?: string, projectFilter?: string): Promise<UsageSummary>;
+export declare function getCurrentSessionUsage(sessionId: string): Promise<SessionSummary | null>;
+export declare function getActiveSessionId(): string | null;

package/dist/parser.js

@@ -0,0 +1,246 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUsageSummary = getUsageSummary;
+exports.getCurrentSessionUsage = getCurrentSessionUsage;
+exports.getActiveSessionId = getActiveSessionId;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const readline = __importStar(require("readline"));
+const pricing_1 = require("./pricing");
+function getClaudeDataDir() {
+    const homeDir = os.homedir();
+    return path.join(homeDir, ".claude");
+}
+function getProjectsDir() {
+    return path.join(getClaudeDataDir(), "projects");
+}
+function decodeProjectDirName(encoded) {
+    return encoded.replace(/-/g, path.sep);
+}
+async function parseJsonlFile(filePath) {
+    const sessionId = path.basename(filePath, ".jsonl");
+    let model = "unknown";
+    let totalUsage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheWriteTokens: 0,
+        cacheReadTokens: 0,
+    };
+    let messageCount = 0;
+    let startTime = "";
+    let endTime = "";
+    try {
+        const fileStream = fs.createReadStream(filePath, { encoding: "utf-8" });
+        const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type === "summary") {
+                    if (entry.costUSD !== undefined) {
+                        const projectDir = path.basename(path.dirname(filePath));
+                        const project = decodeProjectDirName(projectDir);
+                        return {
+                            sessionId,
+                            project,
+                            model: entry.model || model,
+                            usage: {
+                                inputTokens: entry.inputTokens || 0,
+                                outputTokens: entry.outputTokens || 0,
+                                cacheWriteTokens: entry.cacheCreationInputTokens || 0,
+                                cacheReadTokens: entry.cacheReadInputTokens || 0,
+                            },
+                            cost: entry.costUSD,
+                            startTime: entry.startTime || "",
+                            endTime: entry.endTime || "",
+                            messageCount: entry.messageCount || 0,
+                        };
+                    }
+                }
+                if (entry.message?.role === "assistant" && entry.message?.usage) {
+                    const usage = entry.message.usage;
+                    totalUsage.inputTokens += usage.input_tokens || 0;
+                    totalUsage.outputTokens += usage.output_tokens || 0;
+                    totalUsage.cacheWriteTokens += usage.cache_creation_input_tokens || 0;
+                    totalUsage.cacheReadTokens += usage.cache_read_input_tokens || 0;
+                    messageCount++;
+                    if (entry.message.model) {
+                        model = entry.message.model;
+                    }
+                }
+                if (entry.timestamp) {
+                    if (!startTime)
+                        startTime = entry.timestamp;
+                    endTime = entry.timestamp;
+                }
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    if (messageCount === 0)
+        return null;
+    const projectDir = path.basename(path.dirname(filePath));
+    const project = decodeProjectDirName(projectDir);
+    const cost = (0, pricing_1.calculateCost)(model, totalUsage.inputTokens, totalUsage.outputTokens, totalUsage.cacheWriteTokens, totalUsage.cacheReadTokens);
+    return {
+        sessionId,
+        project,
+        model,
+        usage: totalUsage,
+        cost,
+        startTime,
+        endTime,
+        messageCount,
+    };
+}
+function getAllJsonlFiles(projectsDir) {
+    const files = [];
+    if (!fs.existsSync(projectsDir))
+        return files;
+    const projectDirs = fs.readdirSync(projectsDir);
+    for (const dir of projectDirs) {
+        const dirPath = path.join(projectsDir, dir);
+        if (!fs.statSync(dirPath).isDirectory())
+            continue;
+        const entries = fs.readdirSync(dirPath);
+        for (const entry of entries) {
+            if (entry.endsWith(".jsonl")) {
+                files.push(path.join(dirPath, entry));
+            }
+        }
+    }
+    return files;
+}
+async function getUsageSummary(startDate, endDate, projectFilter) {
+    const projectsDir = getProjectsDir();
+    const files = getAllJsonlFiles(projectsDir);
+    const summary = {
+        totalCost: 0,
+        totalUsage: { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0 },
+        byProject: {},
+        byModel: {},
+        byDate: {},
+        sessions: [],
+    };
+    for (const file of files) {
+        const session = await parseJsonlFile(file);
+        if (!session)
+            continue;
+        if (projectFilter && !session.project.toLowerCase().includes(projectFilter.toLowerCase())) {
+            continue;
+        }
+        const sessionDate = session.startTime ? session.startTime.split("T")[0] : "";
+        if (startDate && sessionDate && sessionDate < startDate)
+            continue;
+        if (endDate && sessionDate && sessionDate > endDate)
+            continue;
+        summary.totalCost += session.cost;
+        summary.totalUsage.inputTokens += session.usage.inputTokens;
+        summary.totalUsage.outputTokens += session.usage.outputTokens;
+        summary.totalUsage.cacheWriteTokens += session.usage.cacheWriteTokens;
+        summary.totalUsage.cacheReadTokens += session.usage.cacheReadTokens;
+        if (!summary.byProject[session.project]) {
+            summary.byProject[session.project] = {
+                cost: 0,
+                usage: { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0 },
+            };
+        }
+        summary.byProject[session.project].cost += session.cost;
+        summary.byProject[session.project].usage.inputTokens += session.usage.inputTokens;
+        summary.byProject[session.project].usage.outputTokens += session.usage.outputTokens;
+        summary.byProject[session.project].usage.cacheWriteTokens += session.usage.cacheWriteTokens;
+        summary.byProject[session.project].usage.cacheReadTokens += session.usage.cacheReadTokens;
+        if (!summary.byModel[session.model]) {
+            summary.byModel[session.model] = {
+                cost: 0,
+                usage: { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0 },
+            };
+        }
+        summary.byModel[session.model].cost += session.cost;
+        summary.byModel[session.model].usage.inputTokens += session.usage.inputTokens;
+        summary.byModel[session.model].usage.outputTokens += session.usage.outputTokens;
+        summary.byModel[session.model].usage.cacheWriteTokens += session.usage.cacheWriteTokens;
+        summary.byModel[session.model].usage.cacheReadTokens += session.usage.cacheReadTokens;
+        if (sessionDate) {
+            if (!summary.byDate[sessionDate]) {
+                summary.byDate[sessionDate] = {
+                    cost: 0,
+                    usage: { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0 },
+                };
+            }
+            summary.byDate[sessionDate].cost += session.cost;
+            summary.byDate[sessionDate].usage.inputTokens += session.usage.inputTokens;
+            summary.byDate[sessionDate].usage.outputTokens += session.usage.outputTokens;
+            summary.byDate[sessionDate].usage.cacheWriteTokens += session.usage.cacheWriteTokens;
+            summary.byDate[sessionDate].usage.cacheReadTokens += session.usage.cacheReadTokens;
+        }
+        summary.sessions.push(session);
+    }
+    summary.totalCost = Math.round(summary.totalCost * 1000000) / 1000000;
+    return summary;
+}
+async function getCurrentSessionUsage(sessionId) {
+    const projectsDir = getProjectsDir();
+    const files = getAllJsonlFiles(projectsDir);
+    for (const file of files) {
+        if (path.basename(file, ".jsonl") === sessionId) {
+            return parseJsonlFile(file);
+        }
+    }
+    return null;
+}
+function getActiveSessionId() {
+    const claudeDir = getClaudeDataDir();
+    const statsFile = path.join(claudeDir, ".stats");
+    if (fs.existsSync(statsFile)) {
+        try {
+            const content = fs.readFileSync(statsFile, "utf-8");
+            const data = JSON.parse(content);
+            return data.sessionId || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}

package/dist/pricing.d.ts

@@ -0,0 +1,9 @@
+export interface ModelPricing {
+    inputPerMillion: number;
+    outputPerMillion: number;
+    cacheWritePerMillion: number;
+    cacheReadPerMillion: number;
+}
+export declare const MODEL_PRICING: Record<string, ModelPricing>;
+export declare function getPricing(model: string): ModelPricing;
+export declare function calculateCost(model: string, inputTokens: number, outputTokens: number, cacheWriteTokens: number, cacheReadTokens: number): number;

package/dist/pricing.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_PRICING = void 0;
+exports.getPricing = getPricing;
+exports.calculateCost = calculateCost;
+exports.MODEL_PRICING = {
+    "claude-opus-4-6": {
+        inputPerMillion: 15,
+        outputPerMillion: 75,
+        cacheWritePerMillion: 18.75,
+        cacheReadPerMillion: 1.5,
+    },
+    "claude-sonnet-4-6": {
+        inputPerMillion: 3,
+        outputPerMillion: 15,
+        cacheWritePerMillion: 3.75,
+        cacheReadPerMillion: 0.3,
+    },
+    "claude-haiku-4-5-20251001": {
+        inputPerMillion: 0.8,
+        outputPerMillion: 4,
+        cacheWritePerMillion: 1,
+        cacheReadPerMillion: 0.08,
+    },
+    "claude-sonnet-4-5-20250514": {
+        inputPerMillion: 3,
+        outputPerMillion: 15,
+        cacheWritePerMillion: 3.75,
+        cacheReadPerMillion: 0.3,
+    },
+};
+function getPricing(model) {
+    if (exports.MODEL_PRICING[model]) {
+        return exports.MODEL_PRICING[model];
+    }
+    for (const key of Object.keys(exports.MODEL_PRICING)) {
+        if (model.includes(key) || key.includes(model)) {
+            return exports.MODEL_PRICING[key];
+        }
+    }
+    if (model.includes("opus")) {
+        return exports.MODEL_PRICING["claude-opus-4-6"];
+    }
+    if (model.includes("haiku")) {
+        return exports.MODEL_PRICING["claude-haiku-4-5-20251001"];
+    }
+    return exports.MODEL_PRICING["claude-sonnet-4-6"];
+}
+function calculateCost(model, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens) {
+    const pricing = getPricing(model);
+    const cost = (inputTokens / 1000000) * pricing.inputPerMillion +
+        (outputTokens / 1000000) * pricing.outputPerMillion +
+        (cacheWriteTokens / 1000000) * pricing.cacheWritePerMillion +
+        (cacheReadTokens / 1000000) * pricing.cacheReadPerMillion;
+    return Math.round(cost * 1000000) / 1000000;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "cc-usage-mcp",
+  "version": "1.0.0",
+  "description": "Claude Code usage tracking MCP server - cross platform (Win/Mac/Linux)",
+  "main": "dist/index.js",
+  "bin": {
+    "cc-usage-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "keywords": ["mcp", "claude-code", "usage", "billing", "token-tracking"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3",
+    "ts-node": "^10.9.2"
+  }
+}