@nexrall/code-core 1.4.66 → 1.4.68

package/dist/mcp/manager.js

@@ -41,17 +41,40 @@ const client_1 = require("./client");
 const httpClient_1 = require("./httpClient");
 const sseClient_1 = require("./sseClient");
 const index_1 = require("../plugins/index");
+const stats_1 = require("./stats");
 // ─── McpManager ───────────────────────────────────────────────────────────────
 class McpManager {
     constructor() {
         this._clients = new Map();
         // Map: prefixed tool name → server name
         this._toolMap = new Map();
+        // Prompt metadata per server, fetched on first use (the `/` menu, `/mcp prompts`
+        // and positional→named argument mapping all read it). Cleared whenever the
+        // client is dropped, so a reconnect never serves a dead session's list.
+        this._promptCache = 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();
+        // Names the user has switched off. Kept per-manager (not just in the file) so a
+        // toggle takes effect in THIS session, not at the next start.
+        this._disabled = new Set();
+        /** Per-tool call counts and timings — the "is it slow or broken?" answer (spec §42). */
+        this.stats = new stats_1.ToolStats();
+        // The human-facing elicitation handler (set by the host that owns a UI). Null means
+        // "nobody can be asked" — transports then auto-decline, so a server never hangs.
+        this._elicitationHandler = null;
+    }
+    /**
+     * Route every server's elicitation (`elicitation/create`) through this handler —
+     * including servers that connect later, which is why it is also re-applied in
+     * connectAll/enable. Pass null to restore auto-decline.
+     */
+    setElicitationHandler(handler) {
+        this._elicitationHandler = handler;
+        for (const client of this._clients.values())
+            client.setElicitationHandler(handler);
     }
     /** Pick the transport for a server config: stdio (command), Streamable HTTP, or legacy SSE. */
     static makeClient(name, cfg) {
@@ -73,24 +96,38 @@ class McpManager {
             path.join(os.homedir(), '.nexrall', 'mcp.json'),
             path.join(workDir, '.nexrall', 'mcp.json'),
         ];
+        // A list, so the two scopes UNION rather than override: switching a server off in
+        // the project must add to whatever the user file already silences.
+        const disabled = new Set();
         for (const loc of locations) {
             try {
                 const raw = fs.readFileSync(loc, 'utf-8');
                 const cfg = JSON.parse(raw);
                 Object.assign(merged.mcpServers, cfg.mcpServers ?? {});
+                for (const name of cfg.disabledServers ?? [])
+                    disabled.add(name);
             }
             catch {
                 // File doesn't exist or invalid JSON — skip
             }
         }
+        if (disabled.size)
+            merged.disabledServers = [...disabled].sort();
         return merged;
     }
     /** Connect to all configured servers. Errors per-server are logged, not thrown. */
     async connectAll(config) {
+        this._disabled = new Set(config.disabledServers ?? []);
         const entries = Object.entries(config.mcpServers);
         await Promise.all(entries.map(async ([name, serverCfg]) => {
             this._configs.set(name, serverCfg);
+            // Switched off by the user: remember it (so /mcp can list it) and do not spawn.
+            if (this._disabled.has(name)) {
+                this._errors.delete(name);
+                return;
+            }
             const client = McpManager.makeClient(name, serverCfg);
+            client.setElicitationHandler(this._elicitationHandler);
             try {
                 await client.connect();
                 this._clients.set(name, client);
@@ -161,7 +198,14 @@ class McpManager {
         // 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));
-        const racers = [client.callTool(toolName, input), timeoutPromise];
+        // Timing covers the whole path the user waits on (server round-trip AND the
+        // race against the 60s timeout / abort), which is what "how long did that take"
+        // means from the outside. The tool name recorded is the PREFIXED one, so the
+        // stats of two servers with a same-named tool never merge.
+        const startedAt = Date.now();
+        this.stats.begin();
+        const timed = (p) => p.then((v) => { this.stats.ok(prefixedName, Date.now() - startedAt); return v; }, (e) => { this.stats.fail(prefixedName, Date.now() - startedAt, e.message || String(e)); throw e; });
+        const racers = [timed(client.callTool(toolName, input)), timed(timeoutPromise)];
         if (abortSignal) {
             let pollId;
             const abortPromise = new Promise((_, reject) => {
@@ -172,7 +216,7 @@ class McpManager {
                     }
                 }, 100);
             });
-            racers.push(abortPromise);
+            racers.push(timed(abortPromise));
             // Clearing the poll on whichever branch wins avoids leaving a live interval
             // (and the closure it holds) running for the rest of the process lifetime —
             // the same leak-prevention pattern client.ts uses for its own abort poll.
@@ -180,6 +224,97 @@ class McpManager {
         }
         return Promise.race(racers);
     }
+    /** Resources across connected, enabled servers. One server failing never hides the others. */
+    async listResources(server) {
+        const out = [];
+        for (const [name, client] of this._clients) {
+            if (server && name !== server)
+                continue;
+            for (const r of await client.listResources())
+                out.push({ ...r, server: name });
+        }
+        return out;
+    }
+    /** Read one resource. Throws a clear error for an unknown server; bounded by the tool timeout. */
+    async readResource(server, uri) {
+        const client = this._clients.get(server);
+        if (!client)
+            throw new Error(`No connected MCP server named "${server}". Connected: ${[...this._clients.keys()].join(', ') || '(none)'}`);
+        let timer;
+        const timeout = new Promise((_, rej) => { timer = setTimeout(() => rej(new Error(`Reading ${uri} timed out after 60s`)), 60000); });
+        try {
+            return await Promise.race([client.readResource(uri), timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    /**
+     * Prompt metadata for one connected server. Fetched once per connection and
+     * cached — including an empty list (server has no prompts capability), so the
+     * `/` menu does not re-ask a server on every keystroke; reconnecting clears
+     * the entry. Returns [] for a server that is not connected.
+     */
+    async promptsFor(server) {
+        const cached = this._promptCache.get(server);
+        if (cached)
+            return cached;
+        const client = this._clients.get(server);
+        if (!client)
+            return [];
+        const list = await client.listPrompts();
+        this._promptCache.set(server, list);
+        return list;
+    }
+    /** Prompts across connected, enabled servers, tagged with the server they came from. */
+    async listPrompts(server) {
+        const out = [];
+        for (const name of this._clients.keys()) {
+            if (server && name !== server)
+                continue;
+            for (const p of await this.promptsFor(name))
+                out.push({ ...p, server: name });
+        }
+        return out;
+    }
+    /**
+     * Expand one prompt to text. Positional values map, in order, onto the
+     * arguments the server declared in prompts/list — the same positional form
+     * Claude Code accepts (`/mcp__server__prompt first second`). Validation runs
+     * here, before the request, so mistakes read as sentences instead of raw
+     * JSON-RPC errors; the request itself is bounded by the same 60s timeout the
+     * resource reader uses.
+     */
+    async getPrompt(server, name, values = []) {
+        const client = this._clients.get(server);
+        if (!client)
+            throw new Error(`No connected MCP server named "${server}". Connected: ${[...this._clients.keys()].join(', ') || '(none)'}`);
+        const list = await this.promptsFor(server);
+        const meta = list.find((p) => p.name === name);
+        if (!meta) {
+            throw new Error(`No MCP prompt named "${name}" on server "${server}"${list.length ? ` (it offers: ${list.map((p) => p.name).join(', ')})` : ''}.`);
+        }
+        const declared = meta.arguments ?? [];
+        if (values.length > declared.length) {
+            throw new Error(`MCP prompt "${server}:${name}" takes ${declared.length} argument(s)${declared.length ? ` (${declared.map((a) => a.name).join(', ')})` : ''} — got ${values.length}.`);
+        }
+        const args = {};
+        declared.forEach((a, i) => { const v = values[i]; if (v !== undefined && v !== '')
+            args[a.name] = v; });
+        const missing = declared.filter((a) => a.required && args[a.name] === undefined);
+        if (missing.length)
+            throw new Error(`MCP prompt "${server}:${name}" is missing required argument(s): ${missing.map((a) => a.name).join(', ')}.`);
+        let timer;
+        const timeout = new Promise((_, rej) => { timer = setTimeout(() => rej(new Error(`MCP prompt ${server}:${name} timed out after 60s`)), 60000); });
+        try {
+            return await Promise.race([client.getPrompt(name, args), timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
     /** True if this tool name belongs to an MCP server. */
     isMcpTool(name) {
         return this._toolMap.has(name);
@@ -195,23 +330,103 @@ class McpManager {
             return cfg.type;
         return cfg?.url && !cfg?.command ? 'http' : 'stdio';
     }
-    /** Returns per-server status for UI display, including failed / auth-required connections. */
+    /** Returns per-server status for UI display, including failed / auth-required / disabled. */
     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 });
+            out.push({ name, transport: McpManager.transportOf(this._configs.get(name)), tools: client.tools, connected: true, disabled: false });
         }
-        for (const [name, error] of this._errors) {
+        for (const name of this._configs.keys()) {
             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) });
+            const disabled = this._disabled.has(name);
+            const error = this._errors.get(name);
+            // A disabled server that never connected has no error to report — say nothing
+            // rather than repeat "disconnected" as if it were a failure.
+            if (disabled && !error) {
+                out.push({ name, transport: McpManager.transportOf(this._configs.get(name)), tools: [], connected: false, disabled: true });
+                continue;
+            }
+            out.push({
+                name, transport: McpManager.transportOf(this._configs.get(name)), tools: [],
+                connected: false, disabled, error, needsAuth: this._needsAuth.has(name),
+            });
         }
-        return out;
+        return out.sort((a, b) => a.name.localeCompare(b.name));
     }
     /** The WWW-Authenticate challenge a server returned on 401 (empty if none/unknown). */
     authChallenge(name) {
         return this._needsAuth.get(name) ?? '';
     }
+    /** True when the user has switched this server off for the session. */
+    isDisabled(name) {
+        return this._disabled.has(name);
+    }
+    /**
+     * Switch a server off in THIS session: drop its client and forget its tool map, so
+     * the next turn's tool list no longer offers it. The caller persists the choice
+     * (McpManager.setServerDisabled) — this method deliberately does not touch disk.
+     */
+    disable(name) {
+        const existed = this._configs.has(name);
+        this._disabled.add(name);
+        this._dropClient(name);
+        return existed;
+    }
+    /**
+     * Switch a server back on and connect it, without a restart. Resolves to an error
+     * message when the connection fails, so the caller can print it and leave the
+     * server listed as broken instead of silently reporting success.
+     */
+    async enable(name) {
+        this._disabled.delete(name);
+        const cfg = this._configs.get(name);
+        if (!cfg)
+            return `no server named "${name}" is configured`;
+        this._dropClient(name);
+        const client = McpManager.makeClient(name, cfg);
+        client.setElicitationHandler(this._elicitationHandler);
+        try {
+            await client.connect();
+        }
+        catch (err) {
+            const msg = err.message;
+            if (err instanceof httpClient_1.McpOAuthRequiredError)
+                this._needsAuth.set(name, err.wwwAuthenticate);
+            this._errors.set(name, msg);
+            return msg;
+        }
+        this._clients.set(name, client);
+        this._errors.delete(name);
+        this._needsAuth.delete(name);
+        for (const tool of client.tools)
+            this._toolMap.set(`${name}__${tool.name}`, name);
+        return null;
+    }
+    /** Disconnect one server for the session (its config stays; `enable` brings it back). */
+    disconnect(name) {
+        const had = this._clients.has(name) || this._errors.has(name);
+        this._dropClient(name);
+        this._errors.set(name, 'disconnected');
+        return had;
+    }
+    /** Forgets one server's client and tools, leaving its config and status alone. */
+    _dropClient(name) {
+        const client = this._clients.get(name);
+        if (client) {
+            try {
+                client.disconnect();
+            }
+            catch { /* best effort */ }
+        }
+        this._clients.delete(name);
+        for (const key of [...this._toolMap.keys()]) {
+            if (this._toolMap.get(key) === name)
+                this._toolMap.delete(key);
+        }
+        this._promptCache.delete(name);
+        this.stats.reset();
+    }
     // ─── Config file persistence (for the management UI) ──────────────────────────
     /** Path to an mcp.json for the given scope. */
     static configPath(workDir, scope) {
@@ -222,7 +437,11 @@ class McpManager {
     static readConfigFile(p) {
         try {
             const cfg = JSON.parse(fs.readFileSync(p, 'utf-8'));
-            return { mcpServers: cfg.mcpServers ?? {} };
+            // `disabledServers` has to survive the read: this is the object that gets written
+            // BACK by addServer/setServerDisabled/removeServer, and dropping the list here
+            // silently un-disabled every server but the one being toggled (found by a test
+            // that switched two off and watched the first reconnect).
+            return { mcpServers: cfg.mcpServers ?? {}, disabledServers: cfg.disabledServers };
         }
         catch {
             return { mcpServers: {} };
@@ -239,17 +458,62 @@ class McpManager {
         cfg.mcpServers[name] = server;
         McpManager.writeConfigFile(p, cfg);
     }
+    /**
+     * Switch a server off/on in the config FILE, so the choice survives a restart.
+     * Written to the project scope even when the server came from elsewhere (a plugin
+     * or the user file), because the project is the only scope this session is sure it
+     * may edit — and `disabledServers` is a name list, so it works for all three.
+     * Returns the file that was written.
+     */
+    static setServerDisabled(workDir, name, disabled, scope = 'project') {
+        const p = McpManager.configPath(workDir, scope);
+        const cfg = McpManager.readConfigFile(p);
+        const current = new Set(cfg.disabledServers ?? []);
+        if (disabled)
+            current.add(name);
+        else
+            current.delete(name);
+        cfg.disabledServers = [...current].sort();
+        if (cfg.disabledServers.length === 0)
+            delete cfg.disabledServers;
+        McpManager.writeConfigFile(p, cfg);
+        return p;
+    }
+    /** Where a server's definition comes from, for messages that have to be honest about it. */
+    static serverScope(workDir, name) {
+        const project = McpManager.readConfigFile(McpManager.configPath(workDir, 'project'));
+        if (project.mcpServers[name])
+            return 'project';
+        const user = McpManager.readConfigFile(McpManager.configPath(workDir, 'user'));
+        if (user.mcpServers[name])
+            return 'user';
+        try {
+            if ((0, index_1.pluginMcpServers)(workDir)[name])
+                return 'plugin';
+        }
+        catch { /* plugin scan is best-effort */ }
+        return 'none';
+    }
     /** 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);
+            let touched = false;
             if (cfg.mcpServers[name]) {
                 delete cfg.mcpServers[name];
-                McpManager.writeConfigFile(p, cfg);
+                touched = true;
                 removed = true;
             }
+            if (cfg.disabledServers?.includes(name)) {
+                cfg.disabledServers = cfg.disabledServers.filter((n) => n !== name);
+                if (cfg.disabledServers.length === 0)
+                    delete cfg.disabledServers;
+                touched = true;
+            }
+            if (touched)
+                McpManager.writeConfigFile(p, cfg);
         }
         return removed;
     }
@@ -261,6 +525,8 @@ class McpManager {
         this._configs.clear();
         this._errors.clear();
         this._needsAuth.clear();
+        this._disabled.clear();
+        this.stats.reset();
     }
 }
 exports.McpManager = McpManager;

package/dist/mcp/server.d.ts

@@ -0,0 +1,39 @@
+import type { Readable, Writable } from 'stream';
+import type { ToolResult } from '../types';
+export interface McpServerTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+    run(input: Record<string, unknown>, ctx: {
+        workDir: string;
+    }): Promise<ToolResult>;
+}
+export interface ServeOptions {
+    /** Workspace root relative paths resolve against (the client's project). */
+    workDir: string;
+    /** Reported in `serverInfo` during initialize. */
+    version?: string;
+    /** Defaults to `readOnlyMcpTools()`. */
+    tools?: McpServerTool[];
+    /** Injectable for tests; default process.stdin/stdout. */
+    input?: Readable;
+    output?: Writable;
+    /** Diagnostics — stderr by convention. NEVER stdout. */
+    log?: (message: string) => void;
+}
+/**
+ * The read-only surface `nex mcp serve` offers. Kept small on purpose: every tool here is one
+ * an outside agent can call with no human in the loop, so nothing that writes, deletes or
+ * executes may join without a permission story first.
+ */
+export declare function readOnlyMcpTools(): McpServerTool[];
+/**
+ * Serve MCP on stdio until the client closes the pipe. Resolves (never rejects) at EOF — the
+ * standard way an MCP client says "stop" is to close stdin, and the exit code is then 0.
+ */
+export declare function serveMcp(opts: ServeOptions): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAI3C,MAAM,WAAW,aAAa;IAC5B,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;IACF,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACpF;AAED,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,KAAK,CAAC,EAAE,aAAa,EAAE,CAAC;IACxB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB,wDAAwD;IACxD,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAaD;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,EAAE,CA+BlD;AASD;;;GAGG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAuHhE"}

package/dist/mcp/server.js

@@ -0,0 +1,189 @@
+"use strict";
+// MCP server — the other direction of `mcp/client.ts`.
+//
+// Point any MCP client at `nex mcp serve` and it can read this machine's files with the same
+// tools the CLI uses. Deliberately READ-ONLY for now: the client is usually another agent with
+// its own permission model, and a server that silently edits files has no one to ask — a write
+// toolset only belongs here once there is a person (or a policy file) behind the approval.
+//
+// Framing is the same newline-delimited JSON-RPC 2.0 the client parses, so our own client is
+// the natural test driver. Two hard rules, both enforced by tests:
+//   * stdout carries protocol frames and NOTHING else — one stray console.log corrupts the
+//     channel; every diagnostic goes to stderr;
+//   * a bad line, an unknown method or a throwing tool must never end the loop.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readOnlyMcpTools = readOnlyMcpTools;
+exports.serveMcp = serveMcp;
+const executor_1 = require("../tools/executor");
+// ─── The toolset ──────────────────────────────────────────────────────────────
+/** Wrap one executor tool. The executor is the single source of behaviour — same caps, same
+ *  error messages, same path resolution as the CLI's own turns. */
+const fromExecutor = (name, description, inputSchema) => ({
+    name,
+    description,
+    inputSchema,
+    run: (input, ctx) => (0, executor_1.executeTool)(name, input, undefined, undefined, ctx.workDir),
+});
+/**
+ * The read-only surface `nex mcp serve` offers. Kept small on purpose: every tool here is one
+ * an outside agent can call with no human in the loop, so nothing that writes, deletes or
+ * executes may join without a permission story first.
+ */
+function readOnlyMcpTools() {
+    return [
+        fromExecutor('read_file', 'Read a text file. Returns numbered lines so later edits can cite them. Binary files are refused.', { type: 'object', properties: {
+                path: { type: 'string', description: 'File path, absolute or relative to the workspace root' },
+                offset: { type: 'number', description: '0-based line to start from (default 0)' },
+                limit: { type: 'number', description: 'How many lines to return' },
+            }, required: ['path'] }),
+        fromExecutor('list_directory', 'List the entries of a directory, each marked as file or directory.', { type: 'object', properties: {
+                path: { type: 'string', description: 'Directory path (default: the workspace root)' },
+            } }),
+        fromExecutor('glob', 'Find files by glob pattern, e.g. "**/*.ts" or "src/**/*.test.js".', { type: 'object', properties: {
+                pattern: { type: 'string', description: 'Glob pattern' },
+                path: { type: 'string', description: 'Directory to search from (default: the workspace root)' },
+            }, required: ['pattern'] }),
+        fromExecutor('search_files', 'Search file contents with a regular expression. Returns matching file paths by default; ask for context lines to get the matches themselves.', { type: 'object', properties: {
+                pattern: { type: 'string', description: 'Regular expression' },
+                path: { type: 'string', description: 'Directory to search (default: the workspace root)' },
+                type: { type: 'string', description: '"files" (paths only) or "content" (matching lines)' },
+                include: { type: 'string', description: 'Only files matching this glob, e.g. "*.ts"' },
+                case_insensitive: { type: 'boolean', description: 'Case-insensitive match' },
+                context_lines: { type: 'number', description: 'Lines of context around each match (implies type "content")' },
+            }, required: ['pattern'] }),
+    ];
+}
+// ─── Protocol ─────────────────────────────────────────────────────────────────
+/** Versions whose framing we actually implement (they are all the same for our surface). */
+const SUPPORTED_PROTOCOLS = ['2024-11-05', '2025-03-26', '2025-06-18'];
+const DEFAULT_PROTOCOL = '2024-11-05';
+const SERVER_NAME = 'nexrall';
+/**
+ * Serve MCP on stdio until the client closes the pipe. Resolves (never rejects) at EOF — the
+ * standard way an MCP client says "stop" is to close stdin, and the exit code is then 0.
+ */
+async function serveMcp(opts) {
+    const input = opts.input ?? process.stdin;
+    const output = opts.output ?? process.stdout;
+    const log = opts.log ?? ((m) => process.stderr.write(`[nexrall mcp] ${m}\n`));
+    const tools = opts.tools ?? readOnlyMcpTools();
+    const version = opts.version ?? '0.0.0';
+    const byName = new Map(tools.map((t) => [t.name, t]));
+    const send = (msg) => { output.write(JSON.stringify(msg) + '\n'); };
+    const reply = (id, result) => send({ jsonrpc: '2.0', id, result });
+    const replyError = (id, code, message) => send({ jsonrpc: '2.0', id, error: { code, message } });
+    async function handle(message) {
+        const id = message.id;
+        const isRequest = id !== undefined && id !== null;
+        const method = message.method;
+        const params = (message.params ?? {});
+        switch (method) {
+            case 'initialize': {
+                // Echo the client's version when we implement it, else our default — that is the
+                // spec's instruction and the number is inert for this surface either way.
+                const asked = typeof params.protocolVersion === 'string' ? params.protocolVersion : '';
+                reply(id, {
+                    protocolVersion: SUPPORTED_PROTOCOLS.includes(asked) ? asked : DEFAULT_PROTOCOL,
+                    capabilities: { tools: {} },
+                    serverInfo: { name: SERVER_NAME, version },
+                    instructions: `Read-only file access to ${opts.workDir}. ` +
+                        `Tools: ${tools.map((t) => t.name).join(', ')}. Nothing here writes, deletes or runs commands.`,
+                });
+                log(`initialize from ${typeof params.clientInfo === 'object' && params.clientInfo ? JSON.stringify(params.clientInfo.name ?? 'client') : 'client'}`);
+                return;
+            }
+            case 'notifications/initialized':
+            case 'notifications/cancelled':
+                return; // notifications take no reply
+            case 'ping':
+                reply(id, {});
+                return;
+            case 'tools/list':
+                reply(id, { tools: tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })) });
+                return;
+            case 'tools/call': {
+                const name = typeof params.name === 'string' ? params.name : '';
+                const args = (params.arguments ?? {});
+                if (!name)
+                    return replyError(id, -32602, 'Invalid params: name is required');
+                const tool = byName.get(name);
+                if (!tool) {
+                    // A RESULT, not a protocol error: the calling model should read "not offered" as tool
+                    // output and pick another route, not see the whole call fail.
+                    reply(id, { content: [{ type: 'text', text: `Tool "${name}" is not offered by this server (read-only). Available: ${[...byName.keys()].join(', ')}.` }], isError: true });
+                    return;
+                }
+                try {
+                    const res = await tool.run(args, { workDir: opts.workDir });
+                    if (res.error)
+                        reply(id, { content: [{ type: 'text', text: res.error }], isError: true });
+                    else
+                        reply(id, { content: [{ type: 'text', text: res.output ?? '' }] });
+                }
+                catch (err) {
+                    // A throwing tool is the tool's problem, not the session's — answer and keep serving.
+                    reply(id, { content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }], isError: true });
+                }
+                return;
+            }
+            default:
+                if (isRequest)
+                    replyError(id, -32601, `Method not found: ${method}`);
+                return;
+        }
+    }
+    input.setEncoding('utf8');
+    let buffer = '';
+    let queue = Promise.resolve();
+    const feed = (line) => {
+        // Chain instead of racing: responses stay in request order and writes never interleave.
+        queue = queue.then(async () => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let message;
+            try {
+                message = JSON.parse(trimmed);
+            }
+            catch {
+                log(`ignoring a line that is not JSON (${trimmed.slice(0, 80)})`);
+                return;
+            }
+            if (!message || message.jsonrpc !== '2.0' || typeof message.method !== 'string') {
+                log('ignoring a message without jsonrpc 2.0 + method');
+                return;
+            }
+            try {
+                await handle(message);
+            }
+            catch (err) {
+                // handle() is written not to throw, so reaching here is a bug in the server — report
+                // it as a JSON-RPC error rather than dropping the connection.
+                if (message.id !== undefined)
+                    replyError(message.id, -32603, err instanceof Error ? err.message : String(err));
+            }
+        });
+    };
+    await new Promise((resolve) => {
+        input.on('data', (chunk) => {
+            buffer += chunk.toString();
+            let nl;
+            while ((nl = buffer.indexOf('\n')) >= 0) {
+                feed(buffer.slice(0, nl));
+                buffer = buffer.slice(nl + 1);
+            }
+        });
+        const done = () => {
+            if (buffer.trim()) {
+                feed(buffer);
+                buffer = '';
+            }
+            resolve();
+        };
+        input.on('end', done);
+        input.on('close', done);
+    });
+    await queue; // let in-flight calls finish before the process exits
+    log('client closed stdin — server exiting');
+}
+//# sourceMappingURL=server.js.map

package/dist/mcp/sseClient.d.ts

@@ -1,4 +1,4 @@
-import type { McpServerConfig, McpToolDefinition, McpTransport } from './client';
+import type { McpServerConfig, McpToolDefinition, McpTransport, McpResource, McpPrompt, McpElicitationHandler } from './client';
 export declare class McpSseClient implements McpTransport {
     private readonly config;
     private _nextId;
@@ -9,10 +9,16 @@ export declare class McpSseClient implements McpTransport {
     private _closed;
     private readonly _pending;
     private _endpointWaiter;
+    private _elicitationHandler;
     readonly name: string;
     constructor(name: string, config: McpServerConfig);
     get tools(): McpToolDefinition[];
+    setElicitationHandler(handler: McpElicitationHandler | null): void;
     connect(): Promise<void>;
+    listResources(): Promise<McpResource[]>;
+    readResource(uri: string): Promise<string>;
+    listPrompts(): Promise<McpPrompt[]>;
+    getPrompt(name: string, args: Record<string, string>): Promise<string>;
     callTool(name: string, args: Record<string, unknown>): Promise<string>;
     disconnect(): void;
     /** Open the GET event stream and wait for the server's `endpoint` event. */

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

@@ -1 +1 @@
-{"version":3,"file":"sseClient.d.ts","sourceRoot":"","sources":["../../src/mcp/sseClient.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AA6BjF,qBAAa,YAAa,YAAW,YAAY;IAWrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAVjD,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0H;IACnJ,OAAO,CAAC,eAAe,CAAoE;IAC3F,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;IAaxB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAc5E,UAAU,IAAI,IAAI;IAalB,4EAA4E;YAC9D,WAAW;IAoCzB,OAAO,CAAC,eAAe;IAYvB,oFAAoF;IACpF,OAAO,CAAC,KAAK;IAWb,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,cAAc;IAuCtB,OAAO,CAAC,IAAI;YAgBE,OAAO;IAIrB,6EAA6E;YAC/D,YAAY;CAwB3B"}
+{"version":3,"file":"sseClient.d.ts","sourceRoot":"","sources":["../../src/mcp/sseClient.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AA6BhI,qBAAa,YAAa,YAAW,YAAY;IAYrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAXjD,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0H;IACnJ,OAAO,CAAC,eAAe,CAAoE;IAC3F,OAAO,CAAC,mBAAmB,CAAsC;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAmB,MAAM,EAAE,eAAe;IAIlE,IAAI,KAAK,IAAI,iBAAiB,EAAE,CAE/B;IAED,qBAAqB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,GAAG,IAAI;IAE5D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxB,aAAa,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAOvC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI1C,WAAW,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAOnC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAMtE,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAc5E,UAAU,IAAI,IAAI;IAalB,4EAA4E;YAC9D,WAAW;IAoCzB,OAAO,CAAC,eAAe;IAYvB,oFAAoF;IACpF,OAAO,CAAC,KAAK;IAWb,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,cAAc;IAqDtB,OAAO,CAAC,IAAI;YAgBE,OAAO;IAIrB,6EAA6E;YAC/D,YAAY;CAwB3B"}