mcp-wtf 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BenYang
+
+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,101 @@
+# mcp-wtf
+
+**Your MCP server won't connect. Find out why in 10 seconds.**
+
+[![CI](https://github.com/Beeeeen/mcp-wtf/actions/workflows/ci.yml/badge.svg)](https://github.com/Beeeeen/mcp-wtf/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/mcp-wtf.svg)](https://www.npmjs.com/package/mcp-wtf)
+[![license](https://img.shields.io/npm/l/mcp-wtf.svg)](./LICENSE)
+
+```bash
+npx mcp-wtf
+```
+
+The host says *"MCP server failed to connect"*, or *"disconnected"*, or nothing at all — the server just isn't there. There are **17,000 GitHub issues** with that exact complaint, because the host throws away the one thing that would explain it: the server's dying words.
+
+mcp-wtf finds every MCP server configured in Claude Desktop, Claude Code, Cursor, Windsurf and VS Code, actually launches each one the way the host would, keeps everything the host discards, and tells you exactly what is wrong — with the fix:
+
+```
+  mcp-wtf  5 of 7 MCP servers are broken -- here is exactly why
+  2 configs searched
+
+  DEAD  github  Claude Desktop
+        x env.GITHUB_PERSONAL_ACCESS_TOKEN is still the placeholder "YOUR_TOKEN_HERE".
+          fix: Put the real value into the "env" block of this server in
+               claude_desktop_config.json.
+
+  DEAD  crashy  Claude Code
+        x The server crashed because a module is missing: left-pad.
+          fix: Its dependencies are not installed. If this is your own server, run
+               npm install in its directory.
+          Error: Cannot find module 'left-pad'
+
+  DEAD  pasted-cmd  Cursor
+        x The command is "npx -y @modelcontextprotocol/server-memory" -- arguments
+          are baked into the command string.
+          fix: Split it: {"command": "npx", "args": ["-y","@modelcontextprotocol/server-memory"]}
+
+  DEAD  py-tools  Claude Desktop
+        x Command not found: "uvx". This produces the classic "spawn uvx ENOENT" error.
+          fix: uv is not on the PATH this process sees. Use the absolute path to uvx
+               (run `which uvx` / `where uvx`), or install uv system-wide.
+
+  WARN  noisy  Claude Desktop, 1 tool, 1ms
+        ! The handshake succeeded, but the server wrote 2 non-JSON lines to stdout.
+          Some hosts survive this; others disconnect at random.
+          fix: Logs belong on stderr. This is the most common cause of
+               "works sometimes, disconnects randomly".
+          > [INFO] server booting...
+
+   OK   filesystem  Claude Desktop, 14 tools, 240ms
+
+  ----------------------------------------------------------------
+  5 broken  |  1 with warnings  |  1 healthy   4.1s
+```
+
+No install, no config, no account, zero dependencies.
+
+---
+
+## What it catches
+
+**Config problems** — the config file itself isn't valid JSON (every server in it is invisible until fixed, and no host tells you); arguments pasted into the `command` string; a `cwd` that doesn't exist; duplicate entries across hosts.
+
+**The classic PATH trap** — `spawn npx ENOENT`. GUI-launched apps on macOS and Windows get a much shorter `PATH` than your terminal, so `npx`, `uvx` and `docker` work in your shell and fail inside the host. mcp-wtf resolves the command exactly the way the OS launcher will (including `PATHEXT` on Windows) and tells you what to paste instead.
+
+**Placeholder credentials** — `YOUR_TOKEN_HERE`, `<your-key>`, `xxx`, `changeme`, `${input:...}`, or an empty `*_TOKEN`. Copied from a README, never replaced, and the server fails with an error the host never shows you.
+
+**Startup crashes, decoded** — missing node modules (`Cannot find module`), packages that don't exist on npm or PyPI, ports already in use from a zombie session, rejected API keys, referenced paths that don't exist, unhandled exceptions. Each stderr signature maps to a plain-language diagnosis, and the raw stderr is quoted underneath.
+
+**stdout pollution** — the server logs to stdout, which *is* the protocol channel on stdio transport. This is the answer to "it works sometimes and then randomly disconnects", and no client library will ever show it to you, because they all silently discard bytes they can't parse. mcp-wtf keeps them.
+
+**Not-actually-MCP** — the command starts an HTTP server, or the wrong entrypoint, or something that waits forever on input. Diagnosed instead of hanging.
+
+## Usage
+
+```bash
+npx mcp-wtf                      # diagnose everything configured on this machine
+npx mcp-wtf --server github      # just one server
+npx mcp-wtf --config ./mcp.json  # one specific config file
+npx mcp-wtf -- node build/index.js       # a server not configured anywhere yet
+npx mcp-wtf --url http://localhost:3000/mcp
+```
+
+`--json` for scripts. Exit codes: `0` all healthy, `1` something is broken, `2` could not run.
+
+## Safety
+
+- mcp-wtf launches your servers exactly as configured, performs the MCP handshake, lists their tools, and shuts them down. **It never invokes a tool.**
+- Env values from your configs are passed to the servers they belong to and are **never printed** — reports name the offending *key*, never the value.
+
+## See also
+
+The rest of the toolchain, built on the same zero-dependency MCP client:
+
+- [**context-xray**](https://github.com/Beeeeen/context-xray) — what your MCP servers *cost*: the context-window tokens they add to every request.
+- [**mcp-probe**](https://github.com/Beeeeen/mcp-probe) — whether your MCP server *behaves*: conformance and robustness tests for CI.
+
+mcp-wtf answers "why won't it connect", context-xray answers "what is it costing me", mcp-probe answers "will it break my users".
+
+## License
+
+MIT

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import { discover } from './discover.js';
+import { diagnoseAll } from './diagnose.js';
+import { renderTerminal } from './report/terminal.js';
+const VERSION = '0.1.0';
+const HELP = `
+  mcp-wtf ${VERSION}
+  Your MCP server won't connect. Find out why in 10 seconds.
+
+  USAGE
+    mcp-wtf                         diagnose every configured MCP server
+    mcp-wtf --config <file>         diagnose the servers in one config file
+    mcp-wtf --server <name>         only the named server(s); repeatable
+    mcp-wtf -- <command> [...]      diagnose one stdio server directly
+    mcp-wtf --url <url>             diagnose one streamable-HTTP server
+
+  OPTIONS
+    --json                  machine-readable report
+    --timeout <ms>          per-server handshake timeout (default 15000)
+    --concurrency <n>       servers checked at once (default 4)
+
+  WHAT IT CHECKS
+    the config itself       valid JSON, commands split from args, cwd exists
+    the command             actually resolvable on PATH (with PATHEXT on
+                            Windows) -- the source of "spawn npx ENOENT"
+    the environment         placeholder API keys ("YOUR_KEY_HERE"), empty
+                            secrets, \${input:...} entries
+    the launch              crashes on start, missing modules, missing
+                            packages, ports already in use, rejected keys
+    the protocol            handshake completes, stdout carries only JSON
+                            (stdout pollution = "disconnects randomly")
+
+  Exit codes: 0 all healthy, 1 something is broken, 2 could not run.
+
+  Configs searched: Claude Desktop, Claude Code (~/.claude.json, ./.mcp.json),
+  Cursor, Windsurf, VS Code. mcp-wtf never invokes your tools, and never
+  prints the values of env secrets.
+`;
+function parseArgs(argv) {
+    const out = {
+        options: { timeoutMs: 15_000, concurrency: 4 },
+        json: false,
+        serverFilter: [],
+        help: false,
+        version: false,
+    };
+    let url = null;
+    const headers = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--') {
+            const rest = argv.slice(i + 1);
+            if (rest.length === 0)
+                return { ...out, error: '`--` must be followed by the server command' };
+            out.direct = { name: rest.join(' '), kind: 'stdio', command: rest[0], args: rest.slice(1), sources: ['command line'] };
+            break;
+        }
+        const next = () => argv[++i];
+        switch (arg) {
+            case '-h':
+            case '--help':
+                out.help = true;
+                break;
+            case '-v':
+            case '--version':
+                out.version = true;
+                break;
+            case '--json':
+                out.json = true;
+                break;
+            case '--config':
+                out.config = next();
+                break;
+            case '--server':
+                out.serverFilter.push(...(next() ?? '').split(',').filter(Boolean));
+                break;
+            case '--url':
+                url = next() ?? null;
+                break;
+            case '--header': {
+                const raw = next() ?? '';
+                const idx = raw.indexOf(':');
+                if (idx < 1)
+                    return { ...out, error: `--header expects "Name: value", got "${raw}"` };
+                headers[raw.slice(0, idx).trim()] = raw.slice(idx + 1).trim();
+                break;
+            }
+            case '--timeout': {
+                const v = Number(next());
+                if (!Number.isFinite(v) || v <= 0)
+                    return { ...out, error: '--timeout needs a positive number of milliseconds' };
+                out.options.timeoutMs = v;
+                break;
+            }
+            case '--concurrency': {
+                const v = Number(next());
+                if (!Number.isFinite(v) || v <= 0)
+                    return { ...out, error: '--concurrency needs a positive number' };
+                out.options.concurrency = Math.floor(v);
+                break;
+            }
+            default:
+                return { ...out, error: `Unknown option "${arg}". Try --help.` };
+        }
+    }
+    if (url)
+        out.direct = { name: url, kind: 'http', url, headers, sources: ['command line'] };
+    return out;
+}
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (parsed.help) {
+        process.stdout.write(HELP);
+        process.exit(0);
+    }
+    if (parsed.version) {
+        process.stdout.write(VERSION + '\n');
+        process.exit(0);
+    }
+    if (parsed.error) {
+        process.stderr.write(`mcp-wtf: ${parsed.error}\n`);
+        process.exit(2);
+    }
+    let specs;
+    let configsSearched = [];
+    let configErrors = [];
+    if (parsed.direct) {
+        specs = [parsed.direct];
+    }
+    else {
+        if (parsed.config && !existsSync(parsed.config)) {
+            process.stderr.write(`mcp-wtf: no such config file: ${parsed.config}\n`);
+            process.exit(2);
+        }
+        const found = discover(parsed.config);
+        specs = found.specs;
+        configsSearched = found.configsSearched;
+        configErrors = found.configErrors;
+        if (parsed.serverFilter.length > 0) {
+            specs = specs.filter((s) => parsed.serverFilter.includes(s.name));
+            const missing = parsed.serverFilter.filter((f) => !specs.some((s) => s.name === f));
+            if (missing.length > 0) {
+                process.stderr.write(`mcp-wtf: no server named ${missing.map((m) => `"${m}"`).join(', ')} in the discovered configs\n`);
+                process.exit(2);
+            }
+        }
+    }
+    if (specs.length === 0 && configErrors.length === 0) {
+        process.stderr.write(configsSearched.length === 0
+            ? 'mcp-wtf: no MCP config files found. Point it at one with --config <file>, or at a server with `mcp-wtf -- <command>`.\n'
+            : `mcp-wtf: searched ${configsSearched.length} config file(s) but found no MCP servers in them.\n`);
+        process.exit(2);
+    }
+    const t0 = Date.now();
+    const diagnoses = await diagnoseAll(specs, parsed.options);
+    const report = {
+        diagnoses,
+        configsSearched,
+        configErrors,
+        healthy: diagnoses.filter((d) => d.verdict === 'healthy').length,
+        broken: diagnoses.filter((d) => d.verdict === 'broken').length,
+        warnings: diagnoses.filter((d) => d.verdict === 'warning').length,
+        durationMs: Date.now() - t0,
+    };
+    if (parsed.json)
+        process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+    else
+        process.stdout.write(renderTerminal(report));
+    process.exit(report.broken > 0 || configErrors.length > 0 ? 1 : 0);
+}
+main().catch((e) => {
+    process.stderr.write(`mcp-wtf: internal error: ${e.stack ?? String(e)}\n`);
+    process.exit(2);
+});

package/dist/client/http.d.ts

@@ -0,0 +1,37 @@
+import type { Transport } from './transport.js';
+import { type JsonRpcResponse } from './jsonrpc.js';
+export interface HttpOptions {
+    url: string;
+    headers?: Record<string, string>;
+}
+/**
+ * Streamable HTTP transport. Each request is a POST; the server may answer
+ * with `application/json` or an SSE stream, and may hand us a session id on
+ * the initialize response that must be echoed on every later call.
+ */
+export declare class HttpTransport implements Transport {
+    private opts;
+    readonly kind = "http";
+    readonly target: string;
+    readonly stdoutNoise: string[];
+    readonly stderr: string[];
+    readonly serverNotifications: JsonRpcResponse[];
+    private nextId;
+    private sessionId;
+    private closed;
+    /** Populated when a response arrives with a shape we could not read. */
+    readonly protocolNotes: string[];
+    constructor(opts: HttpOptions);
+    start(): Promise<void>;
+    private headers;
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<JsonRpcResponse>;
+    requestRaw(payload: Record<string, unknown>, _id: number | string, method: string, timeoutMs?: number): Promise<JsonRpcResponse>;
+    private post;
+    /** Pull the first `data:` frame that carries a JSON-RPC reply. */
+    private parseSse;
+    notify(method: string, params?: unknown): void;
+    writeRaw(text: string): void;
+    isAlive(): boolean;
+    exitInfo(): null;
+    close(): Promise<void>;
+}

package/dist/client/http.js

@@ -0,0 +1,133 @@
+import { TimeoutError, TransportClosedError } from './jsonrpc.js';
+/**
+ * Streamable HTTP transport. Each request is a POST; the server may answer
+ * with `application/json` or an SSE stream, and may hand us a session id on
+ * the initialize response that must be echoed on every later call.
+ */
+export class HttpTransport {
+    opts;
+    kind = 'http';
+    target;
+    stdoutNoise = [];
+    stderr = [];
+    serverNotifications = [];
+    nextId = 1;
+    sessionId = null;
+    closed = false;
+    /** Populated when a response arrives with a shape we could not read. */
+    protocolNotes = [];
+    constructor(opts) {
+        this.opts = opts;
+        this.target = opts.url;
+    }
+    async start() {
+        /* Nothing to spawn; the first POST is the real connection test. */
+    }
+    headers() {
+        const h = {
+            'content-type': 'application/json',
+            accept: 'application/json, text/event-stream',
+            ...this.opts.headers,
+        };
+        if (this.sessionId)
+            h['mcp-session-id'] = this.sessionId;
+        return h;
+    }
+    request(method, params, timeoutMs = 10_000) {
+        const id = this.nextId++;
+        return this.post({ jsonrpc: '2.0', id, method, ...(params !== undefined ? { params } : {}) }, method, timeoutMs);
+    }
+    requestRaw(payload, _id, method, timeoutMs = 10_000) {
+        return this.post(payload, method, timeoutMs);
+    }
+    async post(payload, method, timeoutMs) {
+        if (this.closed)
+            throw new TransportClosedError('Transport already closed');
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), timeoutMs);
+        let res;
+        try {
+            res = await fetch(this.opts.url, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify(payload),
+                signal: ac.signal,
+            });
+        }
+        catch (e) {
+            clearTimeout(timer);
+            if (ac.signal.aborted)
+                throw new TimeoutError(method, timeoutMs);
+            throw new TransportClosedError(`POST ${this.opts.url} failed: ${e.message}`);
+        }
+        clearTimeout(timer);
+        const sid = res.headers.get('mcp-session-id');
+        if (sid)
+            this.sessionId = sid;
+        // 202 with no body is the legal answer to a notification.
+        if (res.status === 202)
+            return {};
+        const ctype = res.headers.get('content-type') ?? '';
+        const body = await res.text();
+        if (!res.ok) {
+            throw new TransportClosedError(`HTTP ${res.status} ${res.statusText} from ${this.opts.url}: ${body.slice(0, 400)}`);
+        }
+        if (ctype.includes('text/event-stream'))
+            return this.parseSse(body, method);
+        if (!body.trim())
+            return {};
+        try {
+            return JSON.parse(body);
+        }
+        catch {
+            this.protocolNotes.push(`Non-JSON body for \`${method}\` (content-type: ${ctype || 'none'}): ${body.slice(0, 200)}`);
+            throw new TransportClosedError(`Server returned unparseable body for \`${method}\``);
+        }
+    }
+    /** Pull the first `data:` frame that carries a JSON-RPC reply. */
+    parseSse(body, method) {
+        const frames = body.split(/\n\n/);
+        let last = null;
+        for (const frame of frames) {
+            const data = frame
+                .split('\n')
+                .filter((l) => l.startsWith('data:'))
+                .map((l) => l.slice(5).trim())
+                .join('');
+            if (!data)
+                continue;
+            let msg;
+            try {
+                msg = JSON.parse(data);
+            }
+            catch {
+                this.protocolNotes.push(`Unparseable SSE frame during \`${method}\`: ${data.slice(0, 200)}`);
+                continue;
+            }
+            if (msg.id !== undefined && msg.id !== null)
+                last = msg;
+            else
+                this.serverNotifications.push(msg);
+        }
+        if (!last)
+            throw new TransportClosedError(`SSE stream for \`${method}\` carried no JSON-RPC response`);
+        return last;
+    }
+    notify(method, params) {
+        void this.post({ jsonrpc: '2.0', method, ...(params !== undefined ? { params } : {}) }, method, 5000).catch(() => {
+            /* Notifications are fire-and-forget; a failure here is not a check result. */
+        });
+    }
+    writeRaw(text) {
+        void fetch(this.opts.url, { method: 'POST', headers: this.headers(), body: text }).catch(() => { });
+    }
+    isAlive() {
+        return !this.closed;
+    }
+    exitInfo() {
+        return null;
+    }
+    async close() {
+        this.closed = true;
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,47 @@
+import type { Transport } from './transport.js';
+import type { JsonRpcResponse } from './jsonrpc.js';
+import type { ToolDef } from '../types.js';
+export { StdioTransport } from './stdio.js';
+export { HttpTransport } from './http.js';
+export type { Transport } from './transport.js';
+/** Versions we will negotiate, newest first. */
+export declare const SUPPORTED_PROTOCOL_VERSIONS: string[];
+export interface HandshakeResult {
+    raw: JsonRpcResponse;
+    protocolVersion: string | null;
+    serverInfo: {
+        name?: string;
+        version?: string;
+    } | null;
+    capabilities: Record<string, unknown>;
+    ms: number;
+}
+/**
+ * A thin, unopinionated MCP client. It performs the handshake and exposes the
+ * few calls the checks need -- but never normalises or repairs a response,
+ * because the checks have to see exactly what the server sent.
+ */
+export declare class McpClient {
+    readonly transport: Transport;
+    private timeoutMs;
+    constructor(transport: Transport, timeoutMs?: number);
+    get target(): string;
+    start(): Promise<void>;
+    initialize(protocolVersion?: string): Promise<HandshakeResult>;
+    /** The spec requires this notification before any other request. */
+    notifyInitialized(): void;
+    call(method: string, params?: unknown, timeoutMs?: number): Promise<JsonRpcResponse>;
+    callRaw(payload: Record<string, unknown>, id: number | string, method: string, timeoutMs?: number): Promise<JsonRpcResponse>;
+    /** Walk `nextCursor` so a paginated server does not under-report. */
+    listAll(method: 'tools/list' | 'resources/list' | 'prompts/list', key: string): Promise<{
+        items: unknown[];
+        pages: number;
+        error?: JsonRpcResponse;
+    }>;
+    listTools(): Promise<{
+        tools: ToolDef[];
+        pages: number;
+        error?: JsonRpcResponse;
+    }>;
+    close(): Promise<void>;
+}

package/dist/client/index.js

@@ -0,0 +1,79 @@
+export { StdioTransport } from './stdio.js';
+export { HttpTransport } from './http.js';
+/** Versions we will negotiate, newest first. */
+export const SUPPORTED_PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
+/**
+ * A thin, unopinionated MCP client. It performs the handshake and exposes the
+ * few calls the checks need -- but never normalises or repairs a response,
+ * because the checks have to see exactly what the server sent.
+ */
+export class McpClient {
+    transport;
+    timeoutMs;
+    constructor(transport, timeoutMs = 10_000) {
+        this.transport = transport;
+        this.timeoutMs = timeoutMs;
+    }
+    get target() {
+        return this.transport.target;
+    }
+    async start() {
+        await this.transport.start();
+    }
+    async initialize(protocolVersion = SUPPORTED_PROTOCOL_VERSIONS[0]) {
+        const t0 = Date.now();
+        const raw = await this.transport.request('initialize', {
+            protocolVersion,
+            capabilities: { roots: { listChanged: true }, sampling: {}, elicitation: {} },
+            clientInfo: { name: 'mcp-wtf', version: '0.1.0' },
+        }, this.timeoutMs);
+        const ms = Date.now() - t0;
+        const result = (raw.result ?? {});
+        return {
+            raw,
+            ms,
+            protocolVersion: typeof result['protocolVersion'] === 'string' ? result['protocolVersion'] : null,
+            serverInfo: result['serverInfo'] ?? null,
+            capabilities: result['capabilities'] ?? {},
+        };
+    }
+    /** The spec requires this notification before any other request. */
+    notifyInitialized() {
+        this.transport.notify('notifications/initialized');
+    }
+    call(method, params, timeoutMs) {
+        return this.transport.request(method, params, timeoutMs ?? this.timeoutMs);
+    }
+    callRaw(payload, id, method, timeoutMs) {
+        return this.transport.requestRaw(payload, id, method, timeoutMs ?? this.timeoutMs);
+    }
+    /** Walk `nextCursor` so a paginated server does not under-report. */
+    async listAll(method, key) {
+        const items = [];
+        let cursor;
+        let pages = 0;
+        for (;;) {
+            const res = await this.call(method, cursor ? { cursor } : {});
+            if (res.error)
+                return { items, pages, error: res };
+            pages++;
+            const result = (res.result ?? {});
+            const batch = result[key];
+            if (Array.isArray(batch))
+                items.push(...batch);
+            const next = result['nextCursor'];
+            if (typeof next === 'string' && next && pages < 50)
+                cursor = next;
+            else
+                break;
+        }
+        return { items, pages };
+    }
+    async listTools() {
+        const { items, pages, error } = await this.listAll('tools/list', 'tools');
+        return { tools: items, pages, error };
+    }
+    close() {
+        return this.transport.close();
+    }
+}

package/dist/client/jsonrpc.d.ts

@@ -0,0 +1,40 @@
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: number | string;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc?: string;
+    id?: number | string | null;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+/** Error codes the spec pins down. Servers get these wrong constantly. */
+export declare const RPC: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+};
+export declare class TimeoutError extends Error {
+    method: string;
+    ms: number;
+    constructor(method: string, ms: number);
+}
+export declare class TransportClosedError extends Error {
+    code?: number | null | undefined;
+    stderr?: string | undefined;
+    constructor(message: string, code?: number | null | undefined, stderr?: string | undefined);
+}

package/dist/client/jsonrpc.js

@@ -0,0 +1,28 @@
+/** Error codes the spec pins down. Servers get these wrong constantly. */
+export const RPC = {
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+};
+export class TimeoutError extends Error {
+    method;
+    ms;
+    constructor(method, ms) {
+        super(`No response to \`${method}\` within ${ms}ms`);
+        this.method = method;
+        this.ms = ms;
+        this.name = 'TimeoutError';
+    }
+}
+export class TransportClosedError extends Error {
+    code;
+    stderr;
+    constructor(message, code, stderr) {
+        super(message);
+        this.code = code;
+        this.stderr = stderr;
+        this.name = 'TransportClosedError';
+    }
+}