@nexrall/code-core 1.0.0

package/dist/mcp/client.d.ts

@@ -0,0 +1,46 @@
+export interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export interface McpServerConfig {
+    /** Transport. Defaults to 'stdio' when a command is set, else inferred from url. */
+    type?: 'stdio' | 'http' | 'sse';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+}
+/** Shared surface implemented by every MCP transport (stdio + HTTP/SSE). */
+export interface McpTransport {
+    readonly name: string;
+    readonly tools: McpToolDefinition[];
+    connect(): Promise<void>;
+    callTool(name: string, args: Record<string, unknown>): Promise<string>;
+    disconnect(): void;
+}
+export declare class McpClient implements McpTransport {
+    private readonly config;
+    private _proc;
+    private _nextId;
+    private _pending;
+    private _buf;
+    private _tools;
+    readonly name: string;
+    constructor(name: string, config: McpServerConfig);
+    get tools(): McpToolDefinition[];
+    connect(): Promise<void>;
+    callTool(name: string, args: Record<string, unknown>): Promise<string>;
+    disconnect(): void;
+    private _request;
+    private _notify;
+    private _send;
+    private _handleLine;
+    private _rejectAll;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/mcp/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/mcp/client.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAED,MAAM,WAAW,eAAe;IAC9B,oFAAoF;IACpF,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;IAEhC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,4EAA4E;AAC5E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,EAAE,CAAC;IACpC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACvE,UAAU,IAAI,IAAI,CAAC;CACpB;AAkBD,qBAAa,SAAU,YAAW,YAAY;IAQlB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPjD,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAAoF;IACpG,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,MAAM,CAA2B;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAmB,MAAM,EAAE,eAAe;IAIlE,IAAI,KAAK,IAAI,iBAAiB,EAAE,CAAwB;IAElD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA2CxB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAiB5E,UAAU,IAAI,IAAI;IAWlB,OAAO,CAAC,QAAQ;IAehB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,KAAK;IAKb,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,UAAU;CAInB"}

package/dist/mcp/client.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClient = void 0;
+const child_process_1 = require("child_process");
+// ─── McpClient ────────────────────────────────────────────────────────────────
+class McpClient {
+    constructor(name, config) {
+        this.config = config;
+        this._proc = null;
+        this._nextId = 1;
+        this._pending = new Map();
+        this._buf = '';
+        this._tools = [];
+        this.name = name;
+    }
+    get tools() { return this._tools; }
+    async connect() {
+        if (!this.config.command)
+            throw new Error(`MCP server "${this.name}" has no command (stdio transport requires one).`);
+        const env = { ...process.env, ...(this.config.env ?? {}) };
+        this._proc = (0, child_process_1.spawn)(this.config.command, this.config.args ?? [], {
+            env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: false,
+        });
+        this._proc.stdout.on('data', (chunk) => {
+            this._buf += chunk.toString('utf-8');
+            let nl;
+            while ((nl = this._buf.indexOf('\n')) !== -1) {
+                const line = this._buf.slice(0, nl).trim();
+                this._buf = this._buf.slice(nl + 1);
+                if (line)
+                    this._handleLine(line);
+            }
+        });
+        this._proc.on('error', (err) => {
+            this._rejectAll(err);
+        });
+        this._proc.on('exit', () => {
+            this._rejectAll(new Error(`MCP server "${this.name}" exited unexpectedly`));
+        });
+        // Handshake: initialize
+        await this._request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'nexrall-code', version: '1.0' },
+        });
+        // Send initialized notification (no response expected)
+        this._notify('notifications/initialized');
+        // Fetch tools
+        const result = await this._request('tools/list', {});
+        this._tools = result?.tools ?? [];
+    }
+    async callTool(name, args) {
+        const result = await this._request('tools/call', { name, arguments: args });
+        if (!result)
+            return '';
+        const text = (result.content ?? [])
+            .filter((c) => c.type === 'text')
+            .map((c) => c.text ?? '')
+            .join('\n');
+        if (result.isError)
+            throw new Error(text || 'MCP tool returned an error');
+        return text;
+    }
+    disconnect() {
+        if (this._proc) {
+            try {
+                this._proc.kill('SIGTERM');
+            }
+            catch { /* ignore */ }
+            this._proc = null;
+        }
+        this._rejectAll(new Error(`MCP server "${this.name}" disconnected`));
+        this._pending.clear();
+    }
+    // ─── Private ────────────────────────────────────────────────────────────────
+    _request(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = this._nextId++;
+            this._pending.set(id, { resolve, reject });
+            this._send({ jsonrpc: '2.0', id, method, params });
+            // Timeout after 30s
+            setTimeout(() => {
+                if (this._pending.has(id)) {
+                    this._pending.delete(id);
+                    reject(new Error(`MCP request "${method}" timed out`));
+                }
+            }, 30000);
+        });
+    }
+    _notify(method, params) {
+        this._send({ jsonrpc: '2.0', method, params });
+    }
+    _send(msg) {
+        if (!this._proc?.stdin?.writable)
+            return;
+        this._proc.stdin.write(JSON.stringify(msg) + '\n');
+    }
+    _handleLine(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (msg.id == null)
+            return; // notification, ignore
+        const pending = this._pending.get(msg.id);
+        if (!pending)
+            return;
+        this._pending.delete(msg.id);
+        if (msg.error) {
+            pending.reject(new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
+        }
+        else {
+            pending.resolve(msg.result);
+        }
+    }
+    _rejectAll(err) {
+        for (const { reject } of this._pending.values())
+            reject(err);
+        this._pending.clear();
+    }
+}
+exports.McpClient = McpClient;
+//# sourceMappingURL=client.js.map

package/dist/mcp/httpClient.d.ts

@@ -0,0 +1,25 @@
+import type { McpServerConfig, McpToolDefinition, McpTransport } from './client';
+/** Thrown when a remote MCP server replies 401 — the caller should run the OAuth flow. */
+export declare class McpOAuthRequiredError extends Error {
+    readonly serverName: string;
+    readonly serverUrl: string;
+    readonly wwwAuthenticate: string;
+    constructor(serverName: string, serverUrl: string, wwwAuthenticate: string);
+}
+export declare class McpHttpClient implements McpTransport {
+    private readonly config;
+    private _nextId;
+    private _tools;
+    private _sessionId;
+    readonly name: string;
+    constructor(name: string, config: McpServerConfig);
+    get tools(): McpToolDefinition[];
+    connect(): Promise<void>;
+    callTool(name: string, args: Record<string, unknown>): Promise<string>;
+    disconnect(): void;
+    private _rpc;
+    private _notify;
+    private _post;
+    private _extractResult;
+}
+//# sourceMappingURL=httpClient.d.ts.map

package/dist/mcp/httpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpClient.d.ts","sourceRoot":"","sources":["../../src/mcp/httpClient.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAqBjF,0FAA0F;AAC1F,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,UAAU,EAAE,MAAM;aAClB,SAAS,EAAE,MAAM;aACjB,eAAe,EAAE,MAAM;gBAFvB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM;CAK1C;AAED,qBAAa,aAAc,YAAW,YAAY;IAMtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IALjD,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,UAAU,CAAuB;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAmB,MAAM,EAAE,eAAe;IAIlE,IAAI,KAAK,IAAI,iBAAiB,EAAE,CAE/B;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAYxB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAc5E,UAAU,IAAI,IAAI;YAaJ,IAAI;YAMJ,OAAO;YAKP,KAAK;YA2BL,cAAc;CAqC7B"}

package/dist/mcp/httpClient.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpHttpClient = exports.McpOAuthRequiredError = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const REQUEST_TIMEOUT_MS = 30000;
+/** Thrown when a remote MCP server replies 401 — the caller should run the OAuth flow. */
+class McpOAuthRequiredError extends Error {
+    constructor(serverName, serverUrl, wwwAuthenticate) {
+        super(`MCP server "${serverName}" requires authentication`);
+        this.serverName = serverName;
+        this.serverUrl = serverUrl;
+        this.wwwAuthenticate = wwwAuthenticate;
+        this.name = 'McpOAuthRequiredError';
+    }
+}
+exports.McpOAuthRequiredError = McpOAuthRequiredError;
+class McpHttpClient {
+    constructor(name, config) {
+        this.config = config;
+        this._nextId = 1;
+        this._tools = [];
+        this._sessionId = null;
+        this.name = name;
+    }
+    get tools() {
+        return this._tools;
+    }
+    async connect() {
+        if (!this.config.url)
+            throw new Error(`MCP server "${this.name}" has no url (http/sse transport requires one).`);
+        await this._rpc('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'nexrall-code', version: '1.0' },
+        });
+        await this._notify('notifications/initialized');
+        const res = (await this._rpc('tools/list', {}));
+        this._tools = res?.tools ?? [];
+    }
+    async callTool(name, args) {
+        const result = (await this._rpc('tools/call', { name, arguments: args }));
+        if (!result)
+            return '';
+        const text = (result.content ?? [])
+            .filter((c) => c.type === 'text')
+            .map((c) => c.text ?? '')
+            .join('\n');
+        if (result.isError)
+            throw new Error(text || 'MCP tool returned an error');
+        return text;
+    }
+    disconnect() {
+        // Best-effort session teardown; ignore failures (server may be stateless).
+        if (this._sessionId && this.config.url) {
+            (0, node_fetch_1.default)(this.config.url, {
+                method: 'DELETE',
+                headers: { 'Mcp-Session-Id': this._sessionId, ...(this.config.headers ?? {}) },
+            }).catch(() => { });
+        }
+        this._sessionId = null;
+    }
+    // ─── Private ──────────────────────────────────────────────────────────────
+    async _rpc(method, params) {
+        const id = this._nextId++;
+        const resp = await this._post({ jsonrpc: '2.0', id, method, params });
+        return this._extractResult(resp, id);
+    }
+    async _notify(method, params) {
+        // Notifications have no id; servers typically reply 202 with no body.
+        await this._post({ jsonrpc: '2.0', method, params });
+    }
+    async _post(body) {
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json, text/event-stream',
+            ...(this.config.headers ?? {}),
+        };
+        if (this._sessionId)
+            headers['Mcp-Session-Id'] = this._sessionId;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let resp;
+        try {
+            resp = await (0, node_fetch_1.default)(this.config.url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const sid = resp.headers.get('mcp-session-id');
+        if (sid)
+            this._sessionId = sid;
+        return resp;
+    }
+    async _extractResult(resp, id) {
+        if (!resp.ok) {
+            if (resp.status === 401) {
+                throw new McpOAuthRequiredError(this.name, this.config.url, resp.headers.get('www-authenticate') ?? '');
+            }
+            const body = await resp.text().catch(() => '');
+            throw new Error(`MCP HTTP ${resp.status} ${resp.statusText}${body ? `: ${body.slice(0, 200)}` : ''}`);
+        }
+        const contentType = resp.headers.get('content-type') ?? '';
+        const text = await resp.text();
+        if (!text.trim())
+            return null; // e.g. 202 ack for a notification
+        const consume = (msg) => {
+            if (msg.error)
+                throw new Error(`MCP error ${msg.error.code}: ${msg.error.message}`);
+            return msg.result ?? null;
+        };
+        if (contentType.includes('text/event-stream')) {
+            // Walk SSE frames; return the JSON-RPC message matching our request id.
+            for (const frame of text.split(/\r?\n\r?\n/)) {
+                const dataLines = frame
+                    .split(/\r?\n/)
+                    .filter((l) => l.startsWith('data:'))
+                    .map((l) => l.slice(5).trim());
+                if (!dataLines.length)
+                    continue;
+                try {
+                    const msg = JSON.parse(dataLines.join('\n'));
+                    if (msg.id === id)
+                        return consume(msg);
+                }
+                catch {
+                    /* skip non-JSON frames (comments, pings) */
+                }
+            }
+            throw new Error('No matching JSON-RPC response found in SSE stream');
+        }
+        return consume(JSON.parse(text));
+    }
+}
+exports.McpHttpClient = McpHttpClient;
+//# sourceMappingURL=httpClient.js.map

package/dist/mcp/manager.d.ts

@@ -0,0 +1,56 @@
+import { McpServerConfig, McpToolDefinition } from './client';
+export interface McpConfig {
+    mcpServers: Record<string, McpServerConfig>;
+}
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export declare class McpManager {
+    private _clients;
+    private _toolMap;
+    private _configs;
+    private _errors;
+    private _needsAuth;
+    /** Pick the transport for a server config: stdio (command), Streamable HTTP, or legacy SSE. */
+    private static makeClient;
+    /** Load config from ~/.nexrall/mcp.json, <workDir>/.nexrall/mcp.json, and plugin mcp.json files. */
+    static loadConfig(workDir: string): McpConfig;
+    /** Connect to all configured servers. Errors per-server are logged, not thrown. */
+    connectAll(config: McpConfig): Promise<void>;
+    /** Returns all MCP tools as Anthropic-compatible tool definitions. */
+    getAnthropicTools(): AnthropicTool[];
+    /** Execute an MCP tool call. Returns null if this tool is not an MCP tool. */
+    callTool(prefixedName: string, input: Record<string, unknown>): Promise<string | null>;
+    /** True if this tool name belongs to an MCP server. */
+    isMcpTool(name: string): boolean;
+    get serverNames(): string[];
+    get toolCount(): number;
+    private static transportOf;
+    /** Returns per-server status for UI display, including failed / auth-required connections. */
+    getStatus(): Array<{
+        name: string;
+        transport: 'stdio' | 'http' | 'sse';
+        tools: McpToolDefinition[];
+        connected: boolean;
+        error?: string;
+        needsAuth?: boolean;
+    }>;
+    /** The WWW-Authenticate challenge a server returned on 401 (empty if none/unknown). */
+    authChallenge(name: string): string;
+    /** Path to an mcp.json for the given scope. */
+    static configPath(workDir: string, scope: 'project' | 'user'): string;
+    private static readConfigFile;
+    private static writeConfigFile;
+    /** Add (or overwrite) a server in the given scope's mcp.json. */
+    static addServer(workDir: string, name: string, server: McpServerConfig, scope?: 'project' | 'user'): void;
+    /** Remove a server from whichever scope(s) define it. Returns true if anything was removed. */
+    static removeServer(workDir: string, name: string): boolean;
+    disconnectAll(): void;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/mcp/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/mcp/manager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAa,eAAe,EAAE,iBAAiB,EAAgB,MAAM,UAAU,CAAC;AAOvF,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC7C;AAGD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE;QACZ,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAID,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAmC;IAEnD,OAAO,CAAC,QAAQ,CAA6B;IAE7C,OAAO,CAAC,QAAQ,CAAsC;IACtD,OAAO,CAAC,OAAO,CAA6B;IAE5C,OAAO,CAAC,UAAU,CAA6B;IAE/C,+FAA+F;IAC/F,OAAO,CAAC,MAAM,CAAC,UAAU;IAMzB,oGAAoG;IACpG,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS;IA2B7C,mFAAmF;IAC7E,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BlD,sEAAsE;IACtE,iBAAiB,IAAI,aAAa,EAAE;IAkBpC,8EAA8E;IACxE,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAkB5F,uDAAuD;IACvD,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIhC,IAAI,WAAW,IAAI,MAAM,EAAE,CAE1B;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,OAAO,CAAC,MAAM,CAAC,WAAW;IAK1B,8FAA8F;IAC9F,SAAS,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;QAAC,KAAK,EAAE,iBAAiB,EAAE,CAAC;QAAC,SAAS,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAY9J,uFAAuF;IACvF,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAMnC,+CAA+C;IAC/C,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,MAAM;IAMrE,OAAO,CAAC,MAAM,CAAC,cAAc;IAS7B,OAAO,CAAC,MAAM,CAAC,eAAe;IAK9B,iEAAiE;IACjE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,KAAK,GAAE,SAAS,GAAG,MAAkB,GAAG,IAAI;IAOrH,+FAA+F;IAC/F,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAc3D,aAAa,IAAI,IAAI;CAQtB"}

package/dist/mcp/manager.js

@@ -0,0 +1,234 @@
+"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.McpManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const client_1 = require("./client");
+const httpClient_1 = require("./httpClient");
+const sseClient_1 = require("./sseClient");
+const index_1 = require("../plugins/index");
+// ─── McpManager ───────────────────────────────────────────────────────────────
+class McpManager {
+    constructor() {
+        this._clients = new Map();
+        // Map: prefixed tool name → server name
+        this._toolMap = new Map();
+        // Config + last connection error per server (for status UI, incl. failures)
+        this._configs = new Map();
+        this._errors = new Map();
+        // Servers that returned 401 → need OAuth. Value = WWW-Authenticate challenge header.
+        this._needsAuth = new Map();
+    }
+    /** Pick the transport for a server config: stdio (command), Streamable HTTP, or legacy SSE. */
+    static makeClient(name, cfg) {
+        if (cfg.type === 'sse')
+            return new sseClient_1.McpSseClient(name, cfg);
+        const isHttp = cfg.type === 'http' || (!cfg.command && !!cfg.url);
+        return isHttp ? new httpClient_1.McpHttpClient(name, cfg) : new client_1.McpClient(name, cfg);
+    }
+    /** Load config from ~/.nexrall/mcp.json, <workDir>/.nexrall/mcp.json, and plugin mcp.json files. */
+    static loadConfig(workDir) {
+        const merged = { mcpServers: {} };
+        // Plugins first, then user, then project — later assignments override, so
+        // a user/project server definition beats a plugin's same-name one.
+        try {
+            Object.assign(merged.mcpServers, (0, index_1.pluginMcpServers)(workDir));
+        }
+        catch { /* plugin scan is best-effort */ }
+        const locations = [
+            path.join(os.homedir(), '.nexrall', 'mcp.json'),
+            path.join(workDir, '.nexrall', 'mcp.json'),
+        ];
+        for (const loc of locations) {
+            try {
+                const raw = fs.readFileSync(loc, 'utf-8');
+                const cfg = JSON.parse(raw);
+                Object.assign(merged.mcpServers, cfg.mcpServers ?? {});
+            }
+            catch {
+                // File doesn't exist or invalid JSON — skip
+            }
+        }
+        return merged;
+    }
+    /** Connect to all configured servers. Errors per-server are logged, not thrown. */
+    async connectAll(config) {
+        const entries = Object.entries(config.mcpServers);
+        await Promise.all(entries.map(async ([name, serverCfg]) => {
+            this._configs.set(name, serverCfg);
+            const client = McpManager.makeClient(name, serverCfg);
+            try {
+                await client.connect();
+                this._clients.set(name, client);
+                this._errors.delete(name);
+                this._needsAuth.delete(name);
+                // Register tools with prefixed names: serverName__toolName
+                for (const tool of client.tools) {
+                    const prefixed = `${name}__${tool.name}`;
+                    this._toolMap.set(prefixed, name);
+                }
+            }
+            catch (err) {
+                if (err instanceof httpClient_1.McpOAuthRequiredError) {
+                    this._needsAuth.set(name, err.wwwAuthenticate);
+                }
+                else {
+                    this._needsAuth.delete(name);
+                }
+                this._errors.set(name, err.message);
+                console.error(`[MCP] Failed to connect to server "${name}": ${err.message}`);
+            }
+        }));
+    }
+    /** Returns all MCP tools as Anthropic-compatible tool definitions. */
+    getAnthropicTools() {
+        const tools = [];
+        for (const [serverName, client] of this._clients) {
+            for (const tool of client.tools) {
+                tools.push({
+                    name: `${serverName}__${tool.name}`,
+                    description: `[${serverName}] ${tool.description}`,
+                    input_schema: {
+                        type: 'object',
+                        properties: tool.inputSchema?.properties ?? {},
+                        required: tool.inputSchema?.required,
+                    },
+                });
+            }
+        }
+        return tools;
+    }
+    /** Execute an MCP tool call. Returns null if this tool is not an MCP tool. */
+    async callTool(prefixedName, input) {
+        const serverName = this._toolMap.get(prefixedName);
+        if (!serverName)
+            return null;
+        const client = this._clients.get(serverName);
+        if (!client)
+            return null;
+        // Strip the server prefix to get the real tool name
+        const toolName = prefixedName.slice(serverName.length + 2);
+        // Enforce a timeout — a hung MCP server would otherwise block the agent loop forever.
+        const MCP_TOOL_TIMEOUT_MS = 60000;
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`MCP tool "${prefixedName}" timed out after ${MCP_TOOL_TIMEOUT_MS / 1000}s`)), MCP_TOOL_TIMEOUT_MS));
+        return Promise.race([client.callTool(toolName, input), timeoutPromise]);
+    }
+    /** True if this tool name belongs to an MCP server. */
+    isMcpTool(name) {
+        return this._toolMap.has(name);
+    }
+    get serverNames() {
+        return [...this._clients.keys()];
+    }
+    get toolCount() {
+        return this._toolMap.size;
+    }
+    static transportOf(cfg) {
+        if (cfg?.type)
+            return cfg.type;
+        return cfg?.url && !cfg?.command ? 'http' : 'stdio';
+    }
+    /** Returns per-server status for UI display, including failed / auth-required connections. */
+    getStatus() {
+        const out = [];
+        for (const [name, client] of this._clients) {
+            out.push({ name, transport: McpManager.transportOf(this._configs.get(name)), tools: client.tools, connected: true });
+        }
+        for (const [name, error] of this._errors) {
+            if (this._clients.has(name))
+                continue;
+            out.push({ name, transport: McpManager.transportOf(this._configs.get(name)), tools: [], connected: false, error, needsAuth: this._needsAuth.has(name) });
+        }
+        return out;
+    }
+    /** The WWW-Authenticate challenge a server returned on 401 (empty if none/unknown). */
+    authChallenge(name) {
+        return this._needsAuth.get(name) ?? '';
+    }
+    // ─── Config file persistence (for the management UI) ──────────────────────────
+    /** Path to an mcp.json for the given scope. */
+    static configPath(workDir, scope) {
+        return scope === 'user'
+            ? path.join(os.homedir(), '.nexrall', 'mcp.json')
+            : path.join(workDir, '.nexrall', 'mcp.json');
+    }
+    static readConfigFile(p) {
+        try {
+            const cfg = JSON.parse(fs.readFileSync(p, 'utf-8'));
+            return { mcpServers: cfg.mcpServers ?? {} };
+        }
+        catch {
+            return { mcpServers: {} };
+        }
+    }
+    static writeConfigFile(p, cfg) {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+    }
+    /** Add (or overwrite) a server in the given scope's mcp.json. */
+    static addServer(workDir, name, server, scope = 'project') {
+        const p = McpManager.configPath(workDir, scope);
+        const cfg = McpManager.readConfigFile(p);
+        cfg.mcpServers[name] = server;
+        McpManager.writeConfigFile(p, cfg);
+    }
+    /** Remove a server from whichever scope(s) define it. Returns true if anything was removed. */
+    static removeServer(workDir, name) {
+        let removed = false;
+        for (const scope of ['project', 'user']) {
+            const p = McpManager.configPath(workDir, scope);
+            const cfg = McpManager.readConfigFile(p);
+            if (cfg.mcpServers[name]) {
+                delete cfg.mcpServers[name];
+                McpManager.writeConfigFile(p, cfg);
+                removed = true;
+            }
+        }
+        return removed;
+    }
+    disconnectAll() {
+        for (const client of this._clients.values())
+            client.disconnect();
+        this._clients.clear();
+        this._toolMap.clear();
+        this._configs.clear();
+        this._errors.clear();
+        this._needsAuth.clear();
+    }
+}
+exports.McpManager = McpManager;
+//# sourceMappingURL=manager.js.map

package/dist/mcp/sseClient.d.ts

@@ -0,0 +1,30 @@
+import type { McpServerConfig, McpToolDefinition, McpTransport } from './client';
+export declare class McpSseClient implements McpTransport {
+    private readonly config;
+    private _nextId;
+    private _tools;
+    private _endpointUrl;
+    private _abort;
+    private _sseBuf;
+    private _closed;
+    private readonly _pending;
+    private _endpointWaiter;
+    readonly name: string;
+    constructor(name: string, config: McpServerConfig);
+    get tools(): McpToolDefinition[];
+    connect(): Promise<void>;
+    callTool(name: string, args: Record<string, unknown>): Promise<string>;
+    disconnect(): void;
+    /** Open the GET event stream and wait for the server's `endpoint` event. */
+    private _openStream;
+    private _onStreamClosed;
+    /** Accumulate raw bytes and dispatch complete SSE events (blank-line delimited). */
+    private _feed;
+    private _firstEventBoundary;
+    private _dispatchEvent;
+    private _rpc;
+    private _notify;
+    /** POST a JSON-RPC message to the endpoint discovered via the SSE stream. */
+    private _postMessage;
+}
+//# sourceMappingURL=sseClient.d.ts.map