context-xray 0.1.0

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';
+    }
+}

package/dist/client/stdio.d.ts

@@ -0,0 +1,55 @@
+import type { Transport } from './transport.js';
+import { type JsonRpcResponse } from './jsonrpc.js';
+export interface StdioOptions {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+}
+/**
+ * Newline-delimited JSON-RPC over a child process's stdio.
+ *
+ * Deliberately hand-rolled rather than built on the official SDK: the SDK
+ * discards anything it cannot parse, and the unparseable bytes are exactly
+ * what we are here to find. A single stray `console.log` in a server puts a
+ * non-JSON line on stdout, which corrupts the stream for every client that
+ * connects to it -- and the server author never sees an error.
+ */
+export declare class StdioTransport implements Transport {
+    private opts;
+    readonly kind = "stdio";
+    readonly target: string;
+    private child;
+    private buffer;
+    private nextId;
+    private pending;
+    private exited;
+    /** stdout lines that were not valid JSON. Almost always a logging bug. */
+    readonly stdoutNoise: string[];
+    readonly stderr: string[];
+    /** Pipe faults (EPIPE and friends) seen after the child went away. */
+    readonly pipeErrors: string[];
+    /** Notifications the server pushed at us, kept for later assertions. */
+    readonly serverNotifications: JsonRpcResponse[];
+    constructor(opts: StdioOptions);
+    start(): Promise<void>;
+    private onStdout;
+    private consumeLine;
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<JsonRpcResponse>;
+    /** Send a request with a caller-chosen id/shape, for malformed-input probes. */
+    requestRaw(payload: Record<string, unknown>, id: number | string, method: string, timeoutMs?: number): Promise<JsonRpcResponse>;
+    private send;
+    notify(method: string, params?: unknown): void;
+    /**
+     * Write bytes verbatim. Used to test how the server handles garbage, and the
+     * single choke point for every unsolicited write, so a dead pipe is handled
+     * in exactly one place.
+     */
+    writeRaw(text: string): void;
+    isAlive(): boolean;
+    exitInfo(): {
+        code: number | null;
+        signal: string | null;
+    } | null;
+    close(): Promise<void>;
+}

package/dist/client/stdio.js

@@ -0,0 +1,213 @@
+import { spawn } from 'node:child_process';
+import { TimeoutError, TransportClosedError } from './jsonrpc.js';
+/**
+ * Newline-delimited JSON-RPC over a child process's stdio.
+ *
+ * Deliberately hand-rolled rather than built on the official SDK: the SDK
+ * discards anything it cannot parse, and the unparseable bytes are exactly
+ * what we are here to find. A single stray `console.log` in a server puts a
+ * non-JSON line on stdout, which corrupts the stream for every client that
+ * connects to it -- and the server author never sees an error.
+ */
+export class StdioTransport {
+    opts;
+    kind = 'stdio';
+    target;
+    child = null;
+    buffer = '';
+    nextId = 1;
+    pending = new Map();
+    exited = null;
+    /** stdout lines that were not valid JSON. Almost always a logging bug. */
+    stdoutNoise = [];
+    stderr = [];
+    /** Pipe faults (EPIPE and friends) seen after the child went away. */
+    pipeErrors = [];
+    /** Notifications the server pushed at us, kept for later assertions. */
+    serverNotifications = [];
+    constructor(opts) {
+        this.opts = opts;
+        this.target = [opts.command, ...opts.args].join(' ');
+    }
+    async start() {
+        // On Windows, a bare command name often resolves to a .cmd shim -- npx,
+        // pnpm, yarn all do -- and CreateProcess cannot execute those directly, so
+        // they need a shell. A path to a real executable must NOT go through the
+        // shell, because cmd.exe splits it on spaces and
+        // "C:\Program Files\nodejs\node.exe" becomes "C:\Program".
+        const isWin = process.platform === 'win32';
+        const hasPathSeparator = /[\\/]/.test(this.opts.command);
+        const isExe = /\.(exe|com)$/i.test(this.opts.command);
+        const useShell = isWin && !hasPathSeparator && !isExe;
+        // When the shell is in play it re-parses the whole line, so anything
+        // containing whitespace has to carry its own quotes.
+        const quote = (s) => (useShell && /[\s"^&|<>]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s);
+        const child = spawn(quote(this.opts.command), this.opts.args.map(quote), {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...this.opts.env },
+            cwd: this.opts.cwd,
+            shell: useShell,
+            windowsVerbatimArguments: useShell,
+        });
+        this.child = child;
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => this.onStdout(chunk));
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => {
+            for (const line of chunk.split('\n'))
+                if (line.trim())
+                    this.stderr.push(line);
+        });
+        // Writing to a pipe whose far end has gone emits EPIPE on the stream. With
+        // no listener Node promotes that to an uncaught exception, which would
+        // crash mcp-probe instead of reporting the dead server -- and the whole
+        // contract here is that a broken server produces a report, not a crash.
+        // Whether the write or the exit lands first is a race, so this shows up
+        // on some platforms and not others.
+        const swallow = (e) => {
+            this.pipeErrors.push(e.message);
+        };
+        child.stdin.on('error', swallow);
+        child.stdout.on('error', swallow);
+        child.stderr.on('error', swallow);
+        child.on('exit', (code, signal) => {
+            this.exited = { code, signal };
+            const err = new TransportClosedError(`Server exited (code ${code ?? 'null'}${signal ? `, signal ${signal}` : ''}) with ${this.pending.size} request(s) in flight`, code, this.stderr.slice(-20).join('\n'));
+            for (const [, p] of this.pending) {
+                clearTimeout(p.timer);
+                p.reject(err);
+            }
+            this.pending.clear();
+        });
+        await new Promise((resolve, reject) => {
+            const onError = (e) => reject(new TransportClosedError(`Failed to spawn \`${this.target}\`: ${e.message}`));
+            child.once('error', onError);
+            // Give spawn a tick to fail loudly; a server that dies later is caught
+            // by the in-flight rejection above.
+            setTimeout(() => {
+                child.off('error', onError);
+                resolve();
+            }, 50);
+        });
+    }
+    onStdout(chunk) {
+        this.buffer += chunk;
+        let idx;
+        while ((idx = this.buffer.indexOf('\n')) !== -1) {
+            const line = this.buffer.slice(0, idx).replace(/\r$/, '');
+            this.buffer = this.buffer.slice(idx + 1);
+            if (!line.trim())
+                continue;
+            this.consumeLine(line);
+        }
+    }
+    consumeLine(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            // Not JSON. Record it and keep going -- we want the full list, not just
+            // the first one, so the report can show the author every offending line.
+            if (this.stdoutNoise.length < 50)
+                this.stdoutNoise.push(line);
+            return;
+        }
+        if (msg && typeof msg === 'object' && msg.id !== undefined && msg.id !== null) {
+            const waiter = this.pending.get(msg.id);
+            if (waiter) {
+                clearTimeout(waiter.timer);
+                this.pending.delete(msg.id);
+                waiter.resolve(msg);
+                return;
+            }
+        }
+        // No id, or an id nobody is waiting on: a notification or a stray reply.
+        this.serverNotifications.push(msg);
+    }
+    request(method, params, timeoutMs = 10_000) {
+        const id = this.nextId++;
+        return this.send({ jsonrpc: '2.0', id, method, ...(params !== undefined ? { params } : {}) }, id, method, timeoutMs);
+    }
+    /** Send a request with a caller-chosen id/shape, for malformed-input probes. */
+    requestRaw(payload, id, method, timeoutMs = 10_000) {
+        return this.send(payload, id, method, timeoutMs);
+    }
+    send(payload, id, method, timeoutMs) {
+        if (!this.child || this.exited) {
+            return Promise.reject(new TransportClosedError(`Server is not running (exit code ${this.exited?.code ?? 'unknown'})`, this.exited?.code ?? null, this.stderr.slice(-20).join('\n')));
+        }
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new TimeoutError(method, timeoutMs));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            const failWrite = (message) => {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(new TransportClosedError(`Write to stdin failed: ${message}`));
+            };
+            // write() reports asynchronously through the callback, but it can also
+            // throw synchronously once the stream is destroyed.
+            try {
+                this.child.stdin.write(JSON.stringify(payload) + '\n', (err) => {
+                    if (err)
+                        failWrite(err.message);
+                });
+            }
+            catch (e) {
+                failWrite(e.message);
+            }
+        });
+    }
+    notify(method, params) {
+        this.writeRaw(JSON.stringify({ jsonrpc: '2.0', method, ...(params !== undefined ? { params } : {}) }) + '\n');
+    }
+    /**
+     * Write bytes verbatim. Used to test how the server handles garbage, and the
+     * single choke point for every unsolicited write, so a dead pipe is handled
+     * in exactly one place.
+     */
+    writeRaw(text) {
+        if (!this.child || this.exited || !this.child.stdin.writable)
+            return;
+        try {
+            this.child.stdin.write(text);
+        }
+        catch (e) {
+            // The child can exit between the liveness check and the write landing.
+            this.pipeErrors.push(e.message);
+        }
+    }
+    isAlive() {
+        return this.child !== null && this.exited === null;
+    }
+    exitInfo() {
+        return this.exited;
+    }
+    async close() {
+        for (const [, p] of this.pending)
+            clearTimeout(p.timer);
+        this.pending.clear();
+        const child = this.child;
+        if (!child || this.exited)
+            return;
+        try {
+            child.stdin.end();
+        }
+        catch {
+            /* Pipe already torn down; there is nothing left to close. */
+        }
+        await new Promise((resolve) => {
+            const t = setTimeout(() => {
+                child.kill('SIGKILL');
+                resolve();
+            }, 1500);
+            child.once('exit', () => {
+                clearTimeout(t);
+                resolve();
+            });
+        });
+    }
+}

package/dist/client/transport.d.ts

@@ -0,0 +1,21 @@
+import type { JsonRpcResponse } from './jsonrpc.js';
+/** The surface the checks are written against, so they work over stdio or HTTP. */
+export interface Transport {
+    readonly kind: 'stdio' | 'http';
+    readonly target: string;
+    /** stdout lines that were not valid JSON (stdio only; empty for HTTP). */
+    readonly stdoutNoise: string[];
+    readonly stderr: string[];
+    readonly serverNotifications: JsonRpcResponse[];
+    start(): Promise<void>;
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<JsonRpcResponse>;
+    requestRaw(payload: Record<string, unknown>, id: number | string, method: string, timeoutMs?: number): Promise<JsonRpcResponse>;
+    notify(method: string, params?: unknown): void;
+    writeRaw(text: string): void;
+    isAlive(): boolean;
+    exitInfo(): {
+        code: number | null;
+        signal: string | null;
+    } | null;
+    close(): Promise<void>;
+}

package/dist/client/transport.js

@@ -0,0 +1 @@
+export {};

package/dist/discover.d.ts

@@ -0,0 +1,21 @@
+import type { ServerSpec } from './types.js';
+/**
+ * Every place the well-known hosts keep their MCP configuration. Two shapes
+ * exist in the wild: `mcpServers` (Claude Desktop, Claude Code, Cursor,
+ * Windsurf) and `servers` (VS Code).
+ */
+export declare function knownConfigPaths(platform?: NodeJS.Platform, home?: string, cwd?: string): Array<{
+    path: string;
+    host: string;
+}>;
+/** Pull every server out of one config file. Returns [] when unreadable. */
+export declare function readConfigFile(path: string, host: string): ServerSpec[];
+/**
+ * Search every known location, merge duplicates (the same server configured
+ * in several hosts is one server with several sources), and report which
+ * config files were actually found.
+ */
+export declare function discover(explicitConfig?: string): {
+    specs: ServerSpec[];
+    configsSearched: string[];
+};

package/dist/discover.js

@@ -0,0 +1,126 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Every place the well-known hosts keep their MCP configuration. Two shapes
+ * exist in the wild: `mcpServers` (Claude Desktop, Claude Code, Cursor,
+ * Windsurf) and `servers` (VS Code).
+ */
+export function knownConfigPaths(platform = process.platform, home = homedir(), cwd = process.cwd()) {
+    const paths = [];
+    const push = (path, host) => paths.push({ path, host });
+    if (platform === 'win32') {
+        const appdata = process.env['APPDATA'] ?? join(home, 'AppData', 'Roaming');
+        push(join(appdata, 'Claude', 'claude_desktop_config.json'), 'Claude Desktop');
+        push(join(appdata, 'Code', 'User', 'mcp.json'), 'VS Code');
+    }
+    else if (platform === 'darwin') {
+        push(join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'), 'Claude Desktop');
+        push(join(home, 'Library', 'Application Support', 'Code', 'User', 'mcp.json'), 'VS Code');
+    }
+    else {
+        push(join(home, '.config', 'Claude', 'claude_desktop_config.json'), 'Claude Desktop');
+        push(join(home, '.config', 'Code', 'User', 'mcp.json'), 'VS Code');
+    }
+    push(join(home, '.claude.json'), 'Claude Code');
+    push(join(cwd, '.mcp.json'), 'Claude Code (project)');
+    push(join(home, '.cursor', 'mcp.json'), 'Cursor');
+    push(join(cwd, '.cursor', 'mcp.json'), 'Cursor (project)');
+    push(join(home, '.codeium', 'windsurf', 'mcp_config.json'), 'Windsurf');
+    push(join(cwd, '.vscode', 'mcp.json'), 'VS Code (workspace)');
+    return paths;
+}
+function toSpec(name, raw, source) {
+    if (raw.disabled === true)
+        return null;
+    const sources = [source];
+    const url = typeof raw.url === 'string' ? raw.url : typeof raw.serverUrl === 'string' ? raw.serverUrl : null;
+    if (url) {
+        return { name, kind: 'http', url, headers: raw.headers ?? {}, sources };
+    }
+    if (typeof raw.command !== 'string' || !raw.command)
+        return null;
+    const args = Array.isArray(raw.args) ? raw.args.filter((a) => typeof a === 'string') : [];
+    const spec = {
+        name,
+        kind: 'stdio',
+        command: raw.command,
+        args,
+        env: raw.env ?? {},
+        cwd: typeof raw.cwd === 'string' ? raw.cwd : undefined,
+        sources,
+    };
+    // VS Code configs can reference interactive inputs (${input:apiKey}); those
+    // servers cannot be launched non-interactively, but they should still show
+    // up in the report rather than silently vanish.
+    const joined = [raw.command, ...args, JSON.stringify(spec.env)].join(' ');
+    if (joined.includes('${input:')) {
+        spec.unlaunchable = 'uses ${input:...} placeholders that need interactive values';
+    }
+    return spec;
+}
+/** Pull every server out of one config file. Returns [] when unreadable. */
+export function readConfigFile(path, host) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    const source = `${host} (${path})`;
+    const collect = (block) => {
+        if (!block || typeof block !== 'object' || Array.isArray(block))
+            return;
+        for (const [name, entry] of Object.entries(block)) {
+            const spec = toSpec(name, entry ?? {}, source);
+            if (spec)
+                out.push(spec);
+        }
+    };
+    collect(parsed['mcpServers']);
+    collect(parsed['servers']);
+    // Claude Code also nests per-project servers under `projects`.
+    const projects = parsed['projects'];
+    if (projects && typeof projects === 'object' && !Array.isArray(projects)) {
+        for (const proj of Object.values(projects)) {
+            collect(proj?.['mcpServers']);
+        }
+    }
+    return out;
+}
+/**
+ * Search every known location, merge duplicates (the same server configured
+ * in several hosts is one server with several sources), and report which
+ * config files were actually found.
+ */
+export function discover(explicitConfig) {
+    const candidates = explicitConfig
+        ? [{ path: explicitConfig, host: 'config' }]
+        : knownConfigPaths();
+    const configsSearched = [];
+    const byIdentity = new Map();
+    for (const { path, host } of candidates) {
+        if (!existsSync(path))
+            continue;
+        configsSearched.push(path);
+        for (const spec of readConfigFile(path, host)) {
+            // Identity is what would actually run, not the display name -- two hosts
+            // pointing at the same command are one server. The environment is part
+            // of what runs: the same command with a different env (one with a real
+            // token, one with a placeholder) is a different server, and merging
+            // them would silently drop one from the report.
+            const envKey = JSON.stringify(Object.entries(spec.env ?? {}).sort());
+            const identity = spec.kind === 'http'
+                ? `http|${spec.url}`
+                : `stdio|${spec.command}|${(spec.args ?? []).join(' ')}|${envKey}|${spec.cwd ?? ''}`;
+            const existing = byIdentity.get(identity);
+            if (existing)
+                existing.sources.push(...spec.sources);
+            else
+                byIdentity.set(identity, spec);
+        }
+    }
+    return { specs: [...byIdentity.values()], configsSearched };
+}

package/dist/estimate.d.ts

@@ -0,0 +1,21 @@
+import type { ToolDef } from './types.js';
+/**
+ * Serialise a tool the way hosts actually send it to the model. The wire
+ * field is `input_schema`; measuring the camelCase MCP field would count the
+ * wrong bytes.
+ */
+export declare function wireFormat(tool: ToolDef): Record<string, unknown>;
+/**
+ * Keyless token estimate. Modern tokenizers average a little under 4
+ * characters per token on English prose but much less on JSON, which is dense
+ * in punctuation and braces that tokenize one-per-character. Weighting the two
+ * classes separately keeps the estimate honest across schema-heavy payloads
+ * without shipping a tokenizer.
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Ground-truth measurement: ask the Anthropic token counter what the request
+ * costs with the tools attached, subtract what it costs without them. The
+ * counting endpoint is free of charge, so --precise costs nothing to run.
+ */
+export declare function countToolTokens(apiKey: string, tools: ToolDef[]): Promise<number>;

package/dist/estimate.js

@@ -0,0 +1,72 @@
+/**
+ * Serialise a tool the way hosts actually send it to the model. The wire
+ * field is `input_schema`; measuring the camelCase MCP field would count the
+ * wrong bytes.
+ */
+export function wireFormat(tool) {
+    return {
+        name: tool.name,
+        description: tool.description ?? '',
+        input_schema: tool.inputSchema ?? { type: 'object' },
+    };
+}
+/**
+ * Keyless token estimate. Modern tokenizers average a little under 4
+ * characters per token on English prose but much less on JSON, which is dense
+ * in punctuation and braces that tokenize one-per-character. Weighting the two
+ * classes separately keeps the estimate honest across schema-heavy payloads
+ * without shipping a tokenizer.
+ */
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    let structural = 0;
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        // Punctuation and symbols: {}[]":,  etc. tokenize far denser than prose.
+        if ((c >= 0x21 && c <= 0x2f) ||
+            (c >= 0x3a && c <= 0x40) ||
+            (c >= 0x5b && c <= 0x60) ||
+            (c >= 0x7b && c <= 0x7e)) {
+            structural++;
+        }
+    }
+    const prose = text.length - structural;
+    return Math.max(1, Math.round(prose / 4.2 + structural / 1.8));
+}
+const API_URL = 'https://api.anthropic.com/v1/messages/count_tokens';
+const COUNT_MODEL = 'claude-sonnet-5';
+async function countTokensCall(apiKey, tools) {
+    const res = await fetch(API_URL, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+            model: COUNT_MODEL,
+            messages: [{ role: 'user', content: 'hi' }],
+            ...(tools.length > 0 ? { tools } : {}),
+        }),
+    });
+    if (!res.ok) {
+        throw new Error(`count_tokens returned HTTP ${res.status}: ${(await res.text()).slice(0, 200)}`);
+    }
+    const body = (await res.json());
+    if (typeof body.input_tokens !== 'number')
+        throw new Error('count_tokens response had no input_tokens');
+    return body.input_tokens;
+}
+/**
+ * Ground-truth measurement: ask the Anthropic token counter what the request
+ * costs with the tools attached, subtract what it costs without them. The
+ * counting endpoint is free of charge, so --precise costs nothing to run.
+ */
+export async function countToolTokens(apiKey, tools) {
+    const [withTools, baseline] = await Promise.all([
+        countTokensCall(apiKey, tools.map(wireFormat)),
+        countTokensCall(apiKey, []),
+    ]);
+    return Math.max(0, withTools - baseline);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { discover, readConfigFile, knownConfigPaths } from './discover.js';
+export { weighServer, weighAll } from './weigh.js';
+export { estimateTokens, countToolTokens, wireFormat } from './estimate.js';
+export { renderTerminal } from './report/terminal.js';
+export { McpClient, StdioTransport, HttpTransport } from './client/index.js';
+export type { JsonSchema, ServerSpec, ServerWeight, ToolDef, ToolWeight, XrayOptions, XrayReport, } from './types.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { discover, readConfigFile, knownConfigPaths } from './discover.js';
+export { weighServer, weighAll } from './weigh.js';
+export { estimateTokens, countToolTokens, wireFormat } from './estimate.js';
+export { renderTerminal } from './report/terminal.js';
+export { McpClient, StdioTransport, HttpTransport } from './client/index.js';

package/dist/report/terminal.d.ts

@@ -0,0 +1,2 @@
+import type { XrayReport } from '../types.js';
+export declare function renderTerminal(report: XrayReport, top?: number): string;