mcpcost 0.0.0-stage → 0.3.0

package/dist/cli.js

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { homedir } from 'node:os';
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { discoverConfigs, readConfigFile } from './configs.js';
+import { probeRemote, VERSION } from './probe.js';
+import { probeStdio } from './stdio.js';
+import { TOKENIZER } from './tokens.js';
+import { loadCredentials, saveCredentials, credentialsFor, defaultCredentialsPath } from './credentials.js';
+const HELP = `mcpcost ${VERSION}: how many tokens do your MCP servers cost before the first prompt?
+
+Usage
+  mcpcost [options]                 measure every server in the configs it can find
+  mcpcost mcp                       serve the same measurements as an MCP server over stdio
+  mcpcost auth <url>                store credentials for a server that needs auth (see mcpcost auth --help)
+  mcpcost --config <file>           measure one config file (repeatable)
+  mcpcost --url <url>               measure one remote server (repeatable)
+  mcpcost --stdio "<command args>"  measure one local server (repeatable)
+
+Options
+  --window <tokens>    context window for the percentages (default 200000)
+  --budget <tokens>    exit with code 1 when the total is above this
+  --tools <n>          list the n most expensive tools of each server (default 0)
+  --claude             exact counts from the Anthropic count_tokens endpoint (free, needs ANTHROPIC_API_KEY)
+  --model <id>         model for --claude (default claude-opus-5-5)
+  --gemini             exact counts from the Gemini countTokens endpoint (free, needs GEMINI_API_KEY)
+  --gemini-model <id>  model for --gemini (default gemini-3.8-flash)
+  --timeout <ms>       per server (default 15000)
+  --no-stdio           do not start local servers, only measure remote ones
+  --credentials <file> credentials for servers that need auth (default ~/.mcpcost/credentials.json)
+  --json               machine-readable output
+  --help, --version
+
+Config files it looks for: .mcp.json, ~/.claude.json, Claude Desktop, Cursor, VS Code, Windsurf, Gemini CLI.
+Without --claude, tokens are an estimate: ${TOKENIZER} over name, description and input schema of each tool.
+With --claude, the exact count for the model is shown too, as published and with the Claude Code mcp__<server>__ prefix.
+With --gemini, the exact count for Gemini is shown too. With both, --budget and the percentages use the Claude count.
+The same probe runs the public board at https://mcpcost.ulehla.dev`;
+export async function main(argv) {
+    if (argv[0] === 'mcp') {
+        const { serveStdio } = await import('./mcp.js');
+        await serveStdio();
+        return new Promise(() => undefined);
+    }
+    if (argv[0] === 'auth') {
+        const { authCommand } = await import('./auth-cli.js');
+        return authCommand(argv.slice(1));
+    }
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            config: { type: 'string', multiple: true },
+            url: { type: 'string', multiple: true },
+            stdio: { type: 'string', multiple: true },
+            window: { type: 'string', default: '200000' },
+            budget: { type: 'string' },
+            tools: { type: 'string', default: '0' },
+            timeout: { type: 'string', default: '15000' },
+            'no-stdio': { type: 'boolean', default: false },
+            credentials: { type: 'string' },
+            claude: { type: 'boolean', default: false },
+            model: { type: 'string' },
+            gemini: { type: 'boolean', default: false },
+            'gemini-model': { type: 'string' },
+            json: { type: 'boolean', default: false },
+            help: { type: 'boolean', default: false },
+            version: { type: 'boolean', default: false }
+        },
+        allowPositionals: true
+    });
+    if (values.help) {
+        console.log(HELP);
+        return 0;
+    }
+    if (values.version) {
+        console.log(VERSION);
+        return 0;
+    }
+    const window = Number(values.window) || 200_000;
+    const timeoutMs = Number(values.timeout) || 15_000;
+    const topTools = Number(values.tools) || 0;
+    const budget = values.budget ? Number(values.budget) : undefined;
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (values.claude && !apiKey) {
+        console.error('--claude needs ANTHROPIC_API_KEY in the environment. Only the free count_tokens endpoint is called.');
+        return 2;
+    }
+    const claudeFor = (serverName) => (values.claude && apiKey ? { apiKey, model: values.model, serverName } : undefined);
+    const geminiKey = process.env.GEMINI_API_KEY;
+    if (values.gemini && !geminiKey) {
+        console.error('--gemini needs GEMINI_API_KEY in the environment. Only the free countTokens endpoint is called.');
+        return 2;
+    }
+    const gemini = values.gemini && geminiKey ? { apiKey: geminiKey, model: values['gemini-model'] } : undefined;
+    const servers = [];
+    const sources = [];
+    if (values.config?.length) {
+        for (const file of values.config) {
+            const cfg = await readConfigFile(file, 'config');
+            if (!cfg) {
+                console.error(`cannot read ${file}`);
+                return 2;
+            }
+            servers.push(...cfg.servers);
+            sources.push(file);
+        }
+    }
+    for (const url of values.url ?? []) {
+        servers.push({ name: url, source: 'command line', kind: 'remote', url, type: /\/sse\/?$/.test(url) ? 'sse' : 'streamable-http' });
+    }
+    for (const line of values.stdio ?? []) {
+        const [command, ...args] = line.trim().split(/\s+/);
+        servers.push({ name: line, source: 'command line', kind: 'stdio', command, args });
+    }
+    if (!values.config?.length && !values.url?.length && !values.stdio?.length) {
+        const found = await discoverConfigs();
+        for (const cfg of found) {
+            servers.push(...cfg.servers);
+            sources.push(`${cfg.path} (${cfg.client}, ${cfg.servers.length})`);
+        }
+        if (!found.length) {
+            console.error('No MCP config found. Pass --config, --url or --stdio. See --help.');
+            return 2;
+        }
+    }
+    // Credentials for servers that need auth. The file is optional; a missing default file means none.
+    const credentialsFile = values.credentials ?? defaultCredentialsPath();
+    let store = null;
+    try {
+        store = await loadCredentials(credentialsFile);
+    }
+    catch (e) {
+        console.error(`cannot read ${credentialsFile}: ${e instanceof Error ? e.message : String(e)}`);
+        return 2;
+    }
+    const providers = [];
+    const rows = [];
+    const running = [];
+    for (const s of servers) {
+        const row = { name: s.name, source: s.source, kind: s.kind, target: s.kind === 'remote' ? s.url : [s.command, ...(s.args ?? [])].join(' ') };
+        rows.push(row);
+        if (s.disabled) {
+            row.skipped = 'disabled in config';
+            continue;
+        }
+        if (s.kind === 'stdio' && values['no-stdio']) {
+            row.skipped = 'local server, --no-stdio';
+            continue;
+        }
+        let headers = s.headers;
+        let authProvider;
+        if (s.kind === 'remote' && store) {
+            const creds = credentialsFor(store, s.url);
+            if (creds) {
+                // Headers from the config win; the stored ones fill in what the config leaves out.
+                if (creds.headers)
+                    headers = { ...creds.headers, ...(s.headers ?? {}) };
+                authProvider = creds.authProvider;
+                if (authProvider)
+                    providers.push(authProvider);
+                row.withCredentials = true;
+            }
+        }
+        const job = s.kind === 'remote'
+            ? probeRemote({ url: s.url, type: s.type ?? 'streamable-http' }, { timeoutMs, headers, authProvider, claude: claudeFor(s.name), gemini })
+            : probeStdio({ command: s.command, args: s.args, env: s.env, cwd: s.cwd }, { timeoutMs, claude: claudeFor(s.name), gemini });
+        running.push(job.then((r) => void (row.result = r)));
+    }
+    await Promise.all(running);
+    // A refreshed token goes back to the file.
+    if (store && providers.some((p) => p.changed))
+        await saveCredentials(store, credentialsFile).catch((e) => console.error(`cannot write ${credentialsFile}: ${e instanceof Error ? e.message : String(e)}`));
+    const measured = rows.filter((r) => r.result?.status === 'ok');
+    /** The number a row is ranked and budgeted by: the exact Claude count with --claude, else the Gemini count with --gemini, else the estimate. */
+    const basis = values.claude ? 'claude' : values.gemini ? 'gemini' : 'estimate';
+    const exact = basis !== 'estimate';
+    const cost = (r) => (basis === 'claude' ? r.result?.claude?.tokens : basis === 'gemini' ? r.result?.gemini?.tokens : r.result?.toolsTokens);
+    const total = measured.reduce((a, r) => a + (cost(r) ?? 0), 0);
+    const totalEstimate = measured.reduce((a, r) => a + (r.result?.toolsTokens ?? 0), 0);
+    const totalTools = measured.reduce((a, r) => a + (r.result?.toolCount ?? 0), 0);
+    const model = basis === 'gemini'
+        ? (measured.find((r) => r.result?.gemini?.model)?.result?.gemini?.model ?? values['gemini-model'] ?? 'gemini-3.8-flash')
+        : (measured.find((r) => r.result?.claude?.model)?.result?.claude?.model ?? values.model ?? 'claude-opus-5-5');
+    const geminiModel = measured.find((r) => r.result?.gemini?.model)?.result?.gemini?.model ?? values['gemini-model'] ?? 'gemini-3.8-flash';
+    rows.sort((a, b) => (cost(b) ?? -1) - (cost(a) ?? -1));
+    if (values.json) {
+        console.log(JSON.stringify({
+            version: VERSION,
+            tokenizer: TOKENIZER,
+            exact: basis === 'claude' ? { endpoint: 'count_tokens', model, provider: 'anthropic' } : basis === 'gemini' ? { endpoint: 'countTokens', model, provider: 'google' } : null,
+            window,
+            sources,
+            total: { servers: measured.length, tools: totalTools, tokens: total, tokensEstimate: totalEstimate, shareOfWindow: total / window },
+            servers: rows.map((r) => ({
+                name: r.name,
+                source: r.source,
+                kind: r.kind,
+                target: r.target,
+                skipped: r.skipped,
+                withCredentials: r.withCredentials || undefined,
+                status: r.result?.status,
+                error: r.result?.error,
+                toolCount: r.result?.toolCount,
+                /** The number the row is ranked and budgeted by, on the basis above. */
+                tokens: cost(r),
+                toolsTokens: r.result?.toolsTokens,
+                claudeTokens: r.result?.claude?.tokens,
+                claudeTokensClaudeCode: r.result?.claude?.tokensClaudeCode,
+                claudeError: r.result?.claude?.error,
+                geminiTokens: r.result?.gemini?.tokens,
+                geminiModel: r.result?.gemini?.model,
+                geminiError: r.result?.gemini?.error,
+                shareOfWindow: cost(r) != null ? cost(r) / window : undefined,
+                initializeMs: r.result?.latencyMs.initialize,
+                toolsListMs: r.result?.latencyMs.toolsList,
+                protocolVersion: r.result?.protocolVersion,
+                tools: topTools > 0 ? r.result?.tools?.slice().sort((a, b) => b.tokens - a.tokens).slice(0, topTools) : undefined
+            }))
+        }, null, 2));
+    }
+    else {
+        console.log(render(rows, { window, total, totalTools, topTools, sources, basis, model, geminiModel, withGemini: Boolean(gemini), cost }));
+    }
+    if (budget !== undefined && total > budget) {
+        console.error(`\nOver budget: ${fmt(total)} tokens, the budget is ${fmt(budget)}.`);
+        return 1;
+    }
+    return 0;
+}
+function fmt(n) {
+    if (n === undefined || n === null)
+        return '';
+    return n.toLocaleString('en-US').replace(/,/g, ' ');
+}
+function pct(n, window) {
+    const p = (n / window) * 100;
+    return p < 0.1 && n > 0 ? '<0.1 %' : `${p.toFixed(1)} %`;
+}
+function shortSource(source) {
+    return source.replace(homedir(), '~').replace(/ \(project .*\)$/, ' (project)');
+}
+function statusText(r) {
+    if (r.skipped)
+        return `skipped: ${r.skipped}`;
+    const s = r.result?.status;
+    if (!s)
+        return '';
+    if (s === 'ok')
+        return r.withCredentials ? 'alive (credentials)' : 'alive';
+    if (s === 'auth')
+        return `needs auth${r.result?.authScheme ? ` (${r.result.authScheme})` : ''}${r.withCredentials ? ', stored credentials refused' : ''}`;
+    if (s === 'payment')
+        return 'payment required';
+    if (s === 'newer_protocol')
+        return 'newer protocol than this SDK';
+    if (s === 'not_found')
+        return r.kind === 'stdio' ? 'command not found' : 'not found';
+    return s.replace('_', ' ');
+}
+function render(rows, o) {
+    const claude = o.basis === 'claude';
+    const lines = [];
+    lines.push(`mcpcost ${VERSION} · tool definitions your agent loads before the first prompt`);
+    if (o.sources.length)
+        lines.push(o.sources.map((s) => `  ${shortSource(s)}`).join('\n'));
+    lines.push('');
+    if (!rows.length) {
+        lines.push('  No servers in these configs.');
+        return lines.join('\n');
+    }
+    const table = [
+        [
+            'server', 'source', 'result', 'tools',
+            ...(claude ? ['claude', 'claude code'] : []),
+            ...(o.withGemini ? ['gemini'] : []),
+            o.basis === 'estimate' ? 'tokens' : 'o200k',
+            `of ${Math.round(o.window / 1000)}k`
+        ]
+    ];
+    const exactCell = (n, error) => (n != null ? fmt(n) : error ? 'refused' : '');
+    for (const r of rows) {
+        const ok = r.result?.status === 'ok';
+        const c = r.result?.claude;
+        const g = r.result?.gemini;
+        table.push([
+            r.name.length > 28 ? r.name.slice(0, 27) + '…' : r.name,
+            shortSource(r.source).replace(/^.*\//, ''),
+            statusText(r),
+            ok ? fmt(r.result?.toolCount) : '',
+            ...(claude ? [ok ? exactCell(c?.tokens, c?.error) : '', ok ? fmt(c?.tokensClaudeCode) : ''] : []),
+            ...(o.withGemini ? [ok ? exactCell(g?.tokens, g?.error) : ''] : []),
+            ok ? fmt(r.result?.toolsTokens) : '',
+            ok && o.cost(r) != null ? pct(o.cost(r), o.window) : ''
+        ]);
+    }
+    const totalEstimate = rows.reduce((a, r) => a + (r.result?.status === 'ok' ? (r.result.toolsTokens ?? 0) : 0), 0);
+    const totalCc = rows.reduce((a, r) => a + (r.result?.claude?.tokensClaudeCode ?? 0), 0);
+    const totalClaude = rows.reduce((a, r) => a + (r.result?.claude?.tokens ?? 0), 0);
+    const totalGemini = rows.reduce((a, r) => a + (r.result?.gemini?.tokens ?? 0), 0);
+    table.push([
+        'total', '', `${rows.filter((r) => r.result?.status === 'ok').length} of ${rows.length} measured`, fmt(o.totalTools),
+        ...(claude ? [fmt(totalClaude), fmt(totalCc)] : []),
+        ...(o.withGemini ? [fmt(totalGemini)] : []),
+        fmt(totalEstimate), pct(o.total, o.window)
+    ]);
+    const widths = table[0].map((_, i) => Math.max(...table.map((row) => row[i].length)));
+    const right = new Set(table[0].map((_, i) => i).filter((i) => i >= 3));
+    const line = (row) => '  ' + row.map((cell, i) => (right.has(i) ? cell.padStart(widths[i]) : cell.padEnd(widths[i]))).join('  ').trimEnd();
+    lines.push(line(table[0]));
+    lines.push('  ' + widths.map((w) => '─'.repeat(w)).join('  '));
+    for (const row of table.slice(1, -1))
+        lines.push(line(row));
+    lines.push('  ' + widths.map((w) => '─'.repeat(w)).join('  '));
+    lines.push(line(table[table.length - 1]));
+    const failed = rows.filter((r) => r.result && r.result.status !== 'ok' && r.result.error);
+    if (failed.length) {
+        lines.push('');
+        for (const r of failed)
+            lines.push(`  ${r.name}: ${r.result.error.split('\n')[0].slice(0, 160)}`);
+    }
+    if (o.topTools > 0) {
+        for (const r of rows) {
+            if (!r.result?.tools?.length)
+                continue;
+            lines.push('', `  ${r.name}: most expensive tools`);
+            for (const t of [...r.result.tools].sort((a, b) => b.tokens - a.tokens).slice(0, o.topTools)) {
+                lines.push(`    ${fmt(t.tokens).padStart(7)}  ${t.name}`);
+            }
+        }
+    }
+    if (o.basis !== 'estimate') {
+        lines.push('');
+        if (claude)
+            lines.push(`  claude: exact count from the Anthropic count_tokens endpoint for ${o.model}. claude code: the same with the mcp__<server>__ prefix on each tool name.`);
+        if (o.withGemini)
+            lines.push(`  gemini: exact count from the Gemini countTokens endpoint for ${o.geminiModel}.`);
+        lines.push(`  o200k: the estimate without a key, ${TOKENIZER} over name, description and input schema. "refused": the endpoint did not accept the schema.`);
+        const refused = rows.filter((r) => r.result?.claude?.error || r.result?.gemini?.error);
+        for (const r of refused)
+            lines.push(`  ${r.name}: ${(r.result.claude?.error ?? r.result.gemini?.error).slice(0, 160)}`);
+    }
+    else {
+        lines.push('', `  Estimated with ${TOKENIZER} over name, description and input schema of each tool. Claude counts about 1.9 times this. Add --claude for the exact count.`);
+    }
+    return lines.join('\n');
+}
+function invokedDirectly() {
+    if (!process.argv[1])
+        return false;
+    try {
+        // The bin is a symlink in node_modules/.bin, so compare real paths.
+        return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (invokedDirectly()) {
+    main(process.argv.slice(2)).then((code) => process.exit(code), (err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(2);
+    });
+}

package/dist/configs.d.ts

@@ -0,0 +1,41 @@
+import type { RemoteTransport } from './types.js';
+/** One server as a client config describes it. */
+export interface ConfiguredServer {
+    name: string;
+    /** Where it came from: file path, plus the scope inside the file when there is one. */
+    source: string;
+    kind: 'remote' | 'stdio';
+    url?: string;
+    type?: RemoteTransport;
+    headers?: Record<string, string>;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    disabled?: boolean;
+}
+export interface ConfigFile {
+    path: string;
+    /** The client that owns the file. */
+    client: string;
+    servers: ConfiguredServer[];
+}
+export interface DiscoverOptions {
+    cwd?: string;
+    home?: string;
+    platform?: NodeJS.Platform;
+    env?: Record<string, string | undefined>;
+}
+/** Expands ${VAR} and ${VAR:-default} the way Claude Code does in .mcp.json. */
+export declare function expand(value: string, env: Record<string, string | undefined>): string;
+/** Normalises one `{ name: {...} }` map of servers. Accepts the shapes Claude, Cursor, Windsurf and VS Code write. */
+export declare function normalizeServers(map: Record<string, unknown> | undefined, source: string, env?: Record<string, string | undefined>): ConfiguredServer[];
+/** Parses one config file of a known client. Returns null when the file is missing or not JSON. */
+export declare function readConfigFile(file: string, client: string, options?: DiscoverOptions): Promise<ConfigFile | null>;
+/** The places the common clients keep their MCP config. */
+export declare function knownConfigPaths(options?: DiscoverOptions): Array<{
+    path: string;
+    client: string;
+}>;
+/** Reads every known config file that exists. */
+export declare function discoverConfigs(options?: DiscoverOptions): Promise<ConfigFile[]>;

package/dist/configs.js

@@ -0,0 +1,127 @@
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+/** Expands ${VAR} and ${VAR:-default} the way Claude Code does in .mcp.json. */
+export function expand(value, env) {
+    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g, (whole, name, fallback) => {
+        const v = env[name];
+        if (v !== undefined)
+            return v;
+        if (fallback !== undefined)
+            return fallback;
+        return whole;
+    });
+}
+function expandRecord(record, env) {
+    if (!record)
+        return undefined;
+    const out = {};
+    for (const [k, v] of Object.entries(record))
+        if (typeof v === 'string')
+            out[k] = expand(v, env);
+    return out;
+}
+function remoteType(raw, url) {
+    const t = String(raw.type ?? raw.transport ?? '').toLowerCase();
+    if (t === 'sse')
+        return 'sse';
+    if (t === 'http' || t === 'streamable-http' || t === 'streamablehttp' || t === 'streamable_http')
+        return 'streamable-http';
+    return /\/sse\/?$/.test(url) ? 'sse' : 'streamable-http';
+}
+/** Normalises one `{ name: {...} }` map of servers. Accepts the shapes Claude, Cursor, Windsurf and VS Code write. */
+export function normalizeServers(map, source, env = process.env) {
+    if (!map || typeof map !== 'object')
+        return [];
+    const out = [];
+    for (const [name, value] of Object.entries(map)) {
+        if (!value || typeof value !== 'object')
+            continue;
+        const raw = value;
+        const disabled = raw.disabled === true || raw.enabled === false;
+        const url = typeof raw.url === 'string' ? expand(raw.url, env) : typeof raw.serverUrl === 'string' ? expand(raw.serverUrl, env) : undefined;
+        if (url && String(raw.type ?? '').toLowerCase() !== 'stdio') {
+            out.push({ name, source, kind: 'remote', url, type: remoteType(raw, url), headers: expandRecord(raw.headers, env), disabled });
+            continue;
+        }
+        if (typeof raw.command === 'string') {
+            const args = Array.isArray(raw.args) ? raw.args.filter((a) => typeof a === 'string').map((a) => expand(a, env)) : [];
+            out.push({
+                name,
+                source,
+                kind: 'stdio',
+                command: expand(raw.command, env),
+                args,
+                env: expandRecord(raw.env, env),
+                cwd: typeof raw.cwd === 'string' ? expand(raw.cwd, env) : undefined,
+                disabled
+            });
+        }
+    }
+    return out;
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Parses one config file of a known client. Returns null when the file is missing or not JSON. */
+export async function readConfigFile(file, client, options = {}) {
+    const env = options.env ?? process.env;
+    const json = await readJson(file);
+    if (!json)
+        return null;
+    const servers = [];
+    if (client === 'Claude Code (user)') {
+        servers.push(...normalizeServers(json.mcpServers, `${file} (user)`, env));
+        const projects = (json.projects ?? {});
+        const cwd = options.cwd ?? process.cwd();
+        for (const [projectPath, project] of Object.entries(projects)) {
+            if (projectPath === cwd || cwd.startsWith(projectPath.replace(/\/?$/, '/'))) {
+                servers.push(...normalizeServers(project.mcpServers, `${file} (project ${projectPath})`, env));
+            }
+        }
+    }
+    else if (json.servers && typeof json.servers === 'object') {
+        servers.push(...normalizeServers(json.servers, file, env));
+    }
+    else {
+        servers.push(...normalizeServers(json.mcpServers, file, env));
+    }
+    return { path: file, client, servers };
+}
+/** The places the common clients keep their MCP config. */
+export function knownConfigPaths(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? homedir();
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const desktop = platform === 'darwin'
+        ? path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json')
+        : platform === 'win32'
+            ? path.join(env.APPDATA ?? path.join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json')
+            : path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+    return [
+        { path: path.join(cwd, '.mcp.json'), client: 'Claude Code (project)' },
+        { path: path.join(home, '.claude.json'), client: 'Claude Code (user)' },
+        { path: desktop, client: 'Claude Desktop' },
+        { path: path.join(cwd, '.cursor', 'mcp.json'), client: 'Cursor (project)' },
+        { path: path.join(home, '.cursor', 'mcp.json'), client: 'Cursor (user)' },
+        { path: path.join(cwd, '.vscode', 'mcp.json'), client: 'VS Code (workspace)' },
+        { path: path.join(home, '.codeium', 'windsurf', 'mcp_config.json'), client: 'Windsurf' },
+        { path: path.join(home, '.gemini', 'settings.json'), client: 'Gemini CLI' }
+    ];
+}
+/** Reads every known config file that exists. */
+export async function discoverConfigs(options = {}) {
+    const found = [];
+    for (const { path: file, client } of knownConfigPaths(options)) {
+        const cfg = await readConfigFile(file, client, options);
+        if (cfg)
+            found.push(cfg);
+    }
+    return found;
+}

package/dist/core.d.ts

@@ -0,0 +1,37 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
+import type { ProbeResult, ProbeStatus, RemoteTransport } from './types.js';
+export declare const VERSION = "0.3.0";
+export declare const USER_AGENT = "mcpcost/0.3.0 (mcpcost; +https://github.com/ondraulehla/mcpcost)";
+export interface RawTool {
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+}
+export interface CoreOptions {
+    /** Timeout for the whole probe and for each request. Default 15 000 ms. */
+    timeoutMs?: number;
+    /** Extra request headers, for example an Authorization header from your config. */
+    headers?: Record<string, string>;
+    /** An OAuth client with stored tokens; the transport sends them and refreshes them. See credentials.ts. */
+    authProvider?: OAuthClientProvider;
+    fetch?: typeof fetch;
+}
+export interface RawProbe {
+    result: ProbeResult;
+    tools: RawTool[];
+}
+interface Observed {
+    status: number;
+    headers: Headers;
+    url: string;
+}
+export declare function emptyResult(url: string, transport: ProbeResult['transport']): ProbeResult;
+/** Connects to a remote MCP server and lists its tools. No token counting. */
+export declare function probeRemoteRaw(remote: {
+    url: string;
+    type: RemoteTransport;
+}, options?: CoreOptions): Promise<RawProbe>;
+export declare function measure(transport: Transport, result: ProbeResult, timeoutMs: number): Promise<RawTool[]>;
+export declare function classify(message: string | undefined, first: Observed | undefined): ProbeStatus;
+export {};