@jagilber-org/index-server 1.22.0 → 1.26.1

package/dist/server/sdkServer.js

@@ -20,8 +20,10 @@ require("../services/toolHandlers");
 const registry_1 = require("./registry");
 const zod_1 = require("zod");
 const runtimeConfig_1 = require("../config/runtimeConfig");
+const mcpLogBridge_1 = require("../services/mcpLogBridge");
 const handshakeManager_1 = require("./handshakeManager");
 const transportFactory_1 = require("./transportFactory");
+const mcpReadOnlySurfaces_1 = require("./mcpReadOnlySurfaces");
 // ESM dynamic import used below for SDK modules.
 // We'll lazy-load ESM exports via dynamic import when starting.
 let StdioServerTransport;
@@ -50,8 +52,15 @@ function createSdkServer(ServerClass) {
         }
         catch { /* ignore */ }
     }
-    const server = new ServerClass({ name: 'index', version }, { capabilities: { tools: { listChanged: true } } });
+    const serverCapabilities = {
+        tools: { listChanged: true },
+        logging: {},
+        ...(0, mcpReadOnlySurfaces_1.getReadOnlySurfaceCapabilities)(),
+    };
+    const server = new ServerClass({ name: 'index', version }, { capabilities: serverCapabilities });
     server.__declaredVersion = version;
+    // Register server with the MCP log bridge (activated later after ready)
+    (0, mcpLogBridge_1.registerMcpServer)(server);
     // Never emit tools/list_changed before ready. Wrap sendToolListChanged to enforce ordering.
     try {
         const origSendToolListChanged = server.sendToolListChanged?.bind(server);
@@ -102,14 +111,31 @@ function createSdkServer(ServerClass) {
             const result = {
                 protocolVersion: negotiated,
                 serverInfo: { name: 'index', version: versionDeclared },
-                capabilities: { tools: { listChanged: true } },
-                instructions: 'Use initialize -> tools/list -> tools/call { name, arguments }. Health: tools/call health_check. Metrics: tools/call metrics_snapshot. Ping: ping.'
+                capabilities: serverCapabilities,
+                instructions: 'Use initialize -> tools/list -> tools/call { name, arguments }. Prompts: prompts/list and prompts/get. Resources: resources/list and resources/read. Health: tools/call health_check. Metrics: tools/call metrics_snapshot. Ping: ping.'
             };
             (0, handshakeManager_1.initFrameLog)('handler_return', { negotiated });
+            setImmediate(() => {
+                try {
+                    server.__initResponseSent = true;
+                    (0, handshakeManager_1.initFrameLog)('ready_emit_scheduled', { reason: 'initialize-handler' });
+                    (0, handshakeManager_1.emitReadyGlobal)(server, 'initialize-handler');
+                }
+                catch { /* ignore */ }
+            });
             return result;
         }
-        catch {
-            return { protocolVersion: handshakeManager_1.SUPPORTED_PROTOCOL_VERSIONS[0], serverInfo: { name: 'index', version: '0.0.0' }, capabilities: { tools: { listChanged: true } }, instructions: 'init fallback' };
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            try {
+                process.stderr.write(`[startup] initialize_handler_failed ${message}\n`);
+            }
+            catch { /* ignore */ }
+            throw {
+                code: -32603,
+                message: 'Initialize handler failure',
+                data: { message },
+            };
         }
     });
     // Legacy internal _oninitialize patch (will not trigger because we intercept initialize directly)
@@ -122,7 +148,7 @@ function createSdkServer(ServerClass) {
                 const negotiated = (0, handshakeManager_1.negotiateProtocolVersion)(request?.params?.protocolVersion);
                 result.protocolVersion = negotiated;
                 if (result && typeof result === 'object' && !('instructions' in result)) {
-                    result.instructions = 'Use initialize -> tools/list -> tools/call { name, arguments }. Health: tools/call health_check. Metrics: tools/call metrics_snapshot. Ping: ping.';
+                    result.instructions = 'Use initialize -> tools/list -> tools/call { name, arguments }. Prompts: prompts/list and prompts/get. Resources: resources/list and resources/read. Health: tools/call health_check. Metrics: tools/call metrics_snapshot. Ping: ping.';
                 }
                 this.__sawInitializeRequest = true;
             }
@@ -135,6 +161,43 @@ function createSdkServer(ServerClass) {
         const registry = (0, toolRegistry_1.getToolRegistry)();
         return { tools: registry.map(r => ({ name: r.name, description: r.description, inputSchema: r.inputSchema })) };
     });
+    server.setRequestHandler(requestSchema('prompts/list'), async () => {
+        return { prompts: (0, mcpReadOnlySurfaces_1.listReadOnlyPrompts)() };
+    });
+    server.setRequestHandler(zod_1.z.object({
+        jsonrpc: zod_1.z.literal('2.0'),
+        id: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+        method: zod_1.z.literal('prompts/get'),
+        params: zod_1.z.object({
+            _meta: zod_1.z.any().optional(),
+            name: zod_1.z.string(),
+            arguments: zod_1.z.record(zod_1.z.string()).optional(),
+        }),
+    }), async (req) => {
+        const prompt = (0, mcpReadOnlySurfaces_1.getReadOnlyPrompt)(req.params.name, req.params.arguments);
+        if (!prompt) {
+            throw { code: -32602, message: `Unknown prompt: ${req.params.name}`, data: { message: `Unknown prompt: ${req.params.name}`, method: 'prompts/get', name: req.params.name } };
+        }
+        return prompt;
+    });
+    server.setRequestHandler(requestSchema('resources/list'), async () => {
+        return { resources: (0, mcpReadOnlySurfaces_1.listReadOnlyResources)() };
+    });
+    server.setRequestHandler(zod_1.z.object({
+        jsonrpc: zod_1.z.literal('2.0'),
+        id: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+        method: zod_1.z.literal('resources/read'),
+        params: zod_1.z.object({
+            _meta: zod_1.z.any().optional(),
+            uri: zod_1.z.string(),
+        }),
+    }), async (req) => {
+        const resource = (0, mcpReadOnlySurfaces_1.readReadOnlyResource)(req.params.uri);
+        if (!resource) {
+            throw { code: -32602, message: `Unknown resource: ${req.params.uri}`, data: { message: `Unknown resource: ${req.params.uri}`, method: 'resources/read', uri: req.params.uri } };
+        }
+        return resource;
+    });
     // Raw handler for tools/call (MCP style) - returns content array
     server.setRequestHandler(requestSchema('tools/call'), async (req) => {
         const p = req?.params ?? {};
@@ -254,7 +317,6 @@ async function startSdkServer() {
         }
         (0, transportFactory_1.setupKeepalive)();
         (0, handshakeManager_1.setupSafetyFallbacks)(server);
-        (0, transportFactory_1.wrapTransportSend)(server, transport);
         return;
     }
     // Secondary path: StdioServerTransport already loaded

package/dist/server/transport.d.ts

@@ -9,22 +9,21 @@ interface MetricRecord {
  */
 export declare function getMetrics(): Record<string, MetricRecord>;
 /**
- * Register a method handler in the stdio transport's handler table.
- * Unlike the SDK registry, this does not add wrapping (metrics, audit, etc.).
+ * Register a transport-exposed method handler via the canonical registry.
  * @param method - JSON-RPC method name
  * @param handler - Handler function invoked with the parsed params
  */
 export declare function registerHandler<TParams = unknown>(method: string, handler: Handler<TParams>): void;
 /**
- * Return a sorted list of all registered method names in the stdio transport.
+ * Return a sorted list of transport-exposed method names.
  * @returns Array of method name strings in alphabetical order
  */
 export declare function listRegisteredMethods(): string[];
 /**
- * Look up a registered handler by method name.
+ * Look up a canonical registered handler by method name.
  * @param method - JSON-RPC method name to look up
- * @returns The handler function, or `undefined` if not registered
- */
+  * @returns The handler function, or `undefined` if not registered
+  */
 export declare function getHandler(method: string): Handler | undefined;
 export interface TransportOptions {
     input?: NodeJS.ReadableStream;

package/dist/server/transport.js

@@ -22,6 +22,7 @@ exports.startTransport = startTransport;
 const readline_1 = require("readline");
 const validationService_1 = require("../services/validationService");
 const runtimeConfig_1 = require("../config/runtimeConfig");
+const registry_1 = require("./registry");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 // Robust version resolution: attempt cwd + relative to compiled dist location
@@ -42,50 +43,48 @@ for (const p of versionCandidates) {
     }
     catch { /* ignore */ }
 }
-const handlers = {
-    'health_check': () => {
-        // Minimal fallback health; enriched version registered by handlers.metrics.ts overwrites this
-        let instances = [];
-        try {
-            // Dynamic require avoids circular dependency at module load time
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const { getActiveInstances } = require('../dashboard/server/InstanceManager');
-            instances = getActiveInstances().map(i => ({ pid: i.pid, port: i.port, host: i.host, startedAt: i.startedAt, current: i.current }));
-        }
-        catch { /* fail-open */ }
-        return { status: 'ok', timestamp: new Date().toISOString(), version: VERSION, pid: process.pid, uptime: Math.round(process.uptime()), instances };
-    }
-};
-const metrics = {};
 /** Return the in-memory per-method metrics map (count, totalMs, maxMs).
  * @returns Reference to the live metrics map keyed by method name
  */
-function getMetrics() { return metrics; }
-const handlerMeta = {};
+function getMetrics() {
+    return (0, registry_1.getMetricsRaw)();
+}
 /**
- * Register a method handler in the stdio transport's handler table.
- * Unlike the SDK registry, this does not add wrapping (metrics, audit, etc.).
+ * Register a transport-exposed method handler via the canonical registry.
  * @param method - JSON-RPC method name
  * @param handler - Handler function invoked with the parsed params
  */
 function registerHandler(method, handler) {
-    handlers[method] = handler;
-    handlerMeta[method] = { method };
+    (0, registry_1.registerHandler)(method, handler);
 }
 /**
- * Return a sorted list of all registered method names in the stdio transport.
+ * Return a sorted list of transport-exposed method names.
  * @returns Array of method name strings in alphabetical order
  */
 function listRegisteredMethods() {
-    return Object.keys(handlerMeta).sort();
+    return (0, registry_1.listRegisteredMethods)();
 }
 /**
- * Look up a registered handler by method name.
+ * Look up a canonical registered handler by method name.
  * @param method - JSON-RPC method name to look up
- * @returns The handler function, or `undefined` if not registered
- */
+  * @returns The handler function, or `undefined` if not registered
+  */
 function getHandler(method) {
-    return handlers[method];
+    return (0, registry_1.getHandler)(method);
+}
+function getFallbackHealth() {
+    let instances = [];
+    try {
+        // Dynamic require avoids circular dependency at module load time
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { getActiveInstances } = require('../dashboard/server/InstanceManager');
+        instances = getActiveInstances().map(i => ({ pid: i.pid, port: i.port, host: i.host, startedAt: i.startedAt, current: i.current }));
+    }
+    catch { /* fail-open */ }
+    return { status: 'ok', timestamp: new Date().toISOString(), version: VERSION, pid: process.pid, uptime: Math.round(process.uptime()), instances };
+}
+if (!(0, registry_1.getHandler)('health_check')) {
+    (0, registry_1.registerHandler)('health_check', () => getFallbackHealth());
 }
 function makeError(id, code, message, data) {
     return { jsonrpc: '2.0', id: id ?? null, error: { code, message, data } };
@@ -132,6 +131,23 @@ function startTransport(opts = {}) {
         const msg = typeof reason === 'object' && reason && 'message' in reason ? reason.message : String(reason);
         log('error', 'unhandledRejection', { reason: msg });
     });
+    const transportHandlers = {
+        'initialize': (params) => {
+            const p = params;
+            return {
+                protocolVersion: p?.protocolVersion || '2025-06-18',
+                serverInfo: { name: 'index', version: VERSION },
+                capabilities: { roots: { listChanged: true }, tools: { listChanged: true } }
+            };
+        },
+        'notifications/initialized': () => ({ acknowledged: true }),
+        'shutdown': () => ({ shuttingDown: true }),
+        'exit': () => { setTimeout(() => process.exit(0), 0); return { exiting: true }; }
+    };
+    const getAvailableMethods = () => Array.from(new Set([
+        ...Object.keys(transportHandlers),
+        ...(0, registry_1.listRegisteredMethods)(),
+    ])).sort();
     // Handshake state & helpers (deterministic: initialize result flushes, then server/ready)
     let initialized = false;
     let readyEmitted = false;
@@ -145,20 +161,6 @@ function startTransport(opts = {}) {
         }
         catch { /* ignore */ }
     }
-    // Replace initialize handler with direct interception below to control write callback ordering.
-    registerHandler('initialize', (params) => {
-        // This body will be bypassed by explicit fast-path in line reader (kept for compatibility if called indirectly)
-        const p = params;
-        return {
-            protocolVersion: p?.protocolVersion || '2025-06-18',
-            serverInfo: { name: 'index', version: VERSION },
-            capabilities: { roots: { listChanged: true }, tools: { listChanged: true } }
-        };
-    });
-    // Accept notification some clients send post-initialize; respond benignly (single registration)
-    registerHandler('notifications/initialized', () => ({ acknowledged: true }));
-    registerHandler('shutdown', () => ({ shuttingDown: true }));
-    registerHandler('exit', () => { setTimeout(() => process.exit(0), 0); return { exiting: true }; });
     // Use readline only for input parsing; do NOT set output to avoid echoing client-sent
     // JSON-RPC request lines back to stdout (which confused tests expecting only server
     // responses and caused false negatives when matching initialize/result frames).
@@ -208,8 +210,7 @@ function startTransport(opts = {}) {
             }
             initialized = true;
             // Reuse registered initialize handler so future shared logic (capability changes, root listing, etc.) stays centralized.
-            const initHandler = handlers['initialize'];
-            const start = Date.now();
+            const initHandler = transportHandlers['initialize'];
             let resultPayload;
             try {
                 resultPayload = initHandler ? initHandler(req.params) : {
@@ -224,12 +225,6 @@ function startTransport(opts = {}) {
             }
             // Support promise return from handler
             Promise.resolve(resultPayload).then(resolved => {
-                const dur = Date.now() - start;
-                const rec = metrics['initialize'] || (metrics['initialize'] = { count: 0, totalMs: 0, maxMs: 0 });
-                rec.count++;
-                rec.totalMs += dur;
-                if (dur > rec.maxMs)
-                    rec.maxMs = dur;
                 const initResult = { jsonrpc: '2.0', id: req.id ?? 1, result: resolved };
                 try {
                     if (protocolLog) {
@@ -249,10 +244,10 @@ function startTransport(opts = {}) {
             });
             return;
         }
-        const handler = handlers[req.method];
+        const handler = transportHandlers[req.method] ?? (0, registry_1.getHandler)(req.method);
         if (!handler) {
             // Provide richer context for missing method to help client authors.
-            const available = listRegisteredMethods();
+            const available = getAvailableMethods();
             log('debug', 'method_not_found', { requested: req.method, availableCount: available.length });
             respondFn(makeError(req.id ?? null, -32601, 'Method not found', { method: req.method, available }));
             return;
@@ -266,19 +261,12 @@ function startTransport(opts = {}) {
             }
         }
         catch { /* fail-open on validator issues */ }
-        const start = Date.now();
         Promise.resolve()
             .then(() => handler(req.params))
             .then(result => {
             if (!initialized) {
                 log('debug', 'call_before_initialize', { method: req.method });
             }
-            const dur = Date.now() - start;
-            const rec = metrics[req.method] || (metrics[req.method] = { count: 0, totalMs: 0, maxMs: 0 });
-            rec.count++;
-            rec.totalMs += dur;
-            if (dur > rec.maxMs)
-                rec.maxMs = dur;
             if (req.id !== undefined && req.id !== null) {
                 try {
                     if (protocolLog || verbose)
@@ -289,12 +277,6 @@ function startTransport(opts = {}) {
             }
         })
             .catch(e => {
-            const dur = Date.now() - start;
-            const rec = metrics[req.method] || (metrics[req.method] = { count: 0, totalMs: 0, maxMs: 0 });
-            rec.count++;
-            rec.totalMs += dur;
-            if (dur > rec.maxMs)
-                rec.maxMs = dur;
             const maybeErr = e;
             if (maybeErr && typeof maybeErr === 'object' && Number.isSafeInteger(maybeErr.code)) {
                 log('error', 'handler_error', { method: req.method, message: maybeErr.message, code: maybeErr.code });

package/dist/server/transportFactory.d.ts

@@ -1,19 +1,13 @@
 export declare const dynamicImport: (specifier: string) => any;
 /**
- * Set up stdout diagnostics wrapper for backpressure monitoring.
+ * Emit a lightweight diagnostic marker without intercepting stdout writes.
  * Enabled via INDEX_SERVER_TRACE=healthMixed.
  */
 export declare function setupStdoutDiagnostics(): Promise<void>;
 /**
- * Override the internal request dispatcher to retain error.data & emit diagnostics.
- * The upstream SDK has used both `_onRequest` (camel) and `_onrequest` (lower) across versions;
- * we defensively hook whichever exists and assign our wrapper to BOTH names.
+ * Keep diagnostics on public surfaces only; private SDK dispatcher hooks are no longer patched.
  */
-export declare function setupDispatcherOverride(server: any): void;
-/**
- * Wrap transport.send to detect initialize response flush and emit ready.
- */
-export declare function wrapTransportSend(server: any, transport: any): void;
+export declare function setupDispatcherOverride(_server: any): void;
 /**
  * Explicit keepalive to avoid premature process exit before first client request.
  * @param label - Optional label for diagnostic log messages (e.g. 'secondary')