feat: named pipe

Author: EFLKumo

README.md

@@ -16,6 +16,8 @@ npm install mcp-lsp-driver
 pnpm add mcp-lsp-driver
 ```
 
+The package ships dual ESM and CJS builds, so both `import` and `require` work out of the box.
+
 ## Quick Start
 
 ```typescript
@@ -582,6 +584,53 @@ type EditResult =
   | { success: false; message: string; reason: 'UserRejected' | 'IOError' | 'ValidationFailed' }
 ```
 
+## Pipe IPC (Out-of-Process)
+
+When the MCP server runs in a separate process from the IDE plugin (e.g., spawned via stdio transport), the Pipe IPC layer lets the two communicate over a named pipe.
+
+**IDE plugin side** — expose capabilities:
+
+```typescript
+import { serveLspPipe, type IdeCapabilities } from 'mcp-lsp-driver'
+
+const capabilities: IdeCapabilities = {
+  fileAccess: { /* ... */ },
+  definition: { /* ... */ },
+  // ...
+}
+
+const server = await serveLspPipe({
+  pipeName: 'my-ide-lsp',
+  capabilities,
+})
+// server.pipePath  — the resolved pipe path
+// server.connectionCount — number of connected clients
+// await server.close() — shut down
+```
+
+**MCP server side** — connect and use proxy capabilities:
+
+```typescript
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { connectLspPipe, installMcpLspDriver } from 'mcp-lsp-driver'
+
+const conn = await connectLspPipe({
+  pipeName: 'my-ide-lsp',
+  connectTimeout: 5000, // optional, default 5000ms
+})
+
+// conn.capabilities is a full IdeCapabilities proxy
+// conn.availableMethods lists the methods the server exposes
+
+const mcpServer = new McpServer({ name: 'my-mcp', version: '1.0.0' })
+installMcpLspDriver({ server: mcpServer, capabilities: conn.capabilities })
+
+// When done:
+conn.disconnect()
+```
+
+The handshake automatically discovers which providers the server exposes and builds typed proxies. Diagnostics change notifications (`onDiagnosticsChanged`) are forwarded as push notifications to all connected clients. Multiple clients can connect to the same pipe simultaneously.
+
 ## Development
 
 ```bash

package.json

@@ -1,17 +1,29 @@
 {
   "name": "mcp-lsp-driver",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "MCP LSP Driver for IDE plugins to easily expose LSP features via an MCP server.",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
-  "files": ["dist/**/*.js", "dist/**/*.d.ts", "LICENSE"],
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.cjs",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.cts",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsup",
     "test": "vitest run",

src/index.ts

@@ -28,12 +28,15 @@ export type {
   EditProvider,
   FileAccessProvider,
 } from './interfaces.js'
+export type { ConnectLspPipeOptions, LspPipeConnection } from './pipe-client.js'
+export { connectLspPipe } from './pipe-client.js'
+export type { LspPipeServer, ServeLspPipeOptions } from './pipe-server.js'
+// Pipe IPC
+export { serveLspPipe } from './pipe-server.js'
 export type { ResolverConfig } from './resolver.js'
-
 // Symbol Resolver
 export { SymbolResolutionError, SymbolResolver } from './resolver.js'
 export type { McpLspDriverConfig } from './server.js'
-
 // Driver
 export { installMcpLspDriver } from './server.js'
 // Core Data Models

src/pipe-client.ts

@@ -0,0 +1,121 @@
+import { connect } from 'node:net'
+import type { IdeCapabilities } from './capabilities.js'
+import { PipeTransport, PROVIDER_METHODS, toPipePath } from './pipe-protocol.js'
+
+export interface ConnectLspPipeOptions {
+  pipeName: string
+  connectTimeout?: number
+}
+
+export interface LspPipeConnection {
+  readonly capabilities: IdeCapabilities
+  readonly availableMethods: string[]
+  disconnect(): void
+}
+
+export function connectLspPipe(
+  options: ConnectLspPipeOptions,
+): Promise<LspPipeConnection> {
+  const { pipeName, connectTimeout = 5000 } = options
+  const pipePath = toPipePath(pipeName)
+
+  return new Promise((resolve, reject) => {
+    const socket = connect(pipePath)
+    let settled = false
+
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true
+        socket.destroy()
+        reject(new Error(`Connection timeout after ${connectTimeout}ms`))
+      }
+    }, connectTimeout)
+
+    socket.on('error', (err) => {
+      if (!settled) {
+        settled = true
+        clearTimeout(timer)
+        reject(err)
+      }
+    })
+
+    socket.on('connect', () => {
+      clearTimeout(timer)
+      if (settled) return
+
+      let diagnosticsCallback: ((uri: string) => void) | undefined
+
+      const transport = new PipeTransport(socket, {
+        onNotification: (method, params) => {
+          if (method === 'onDiagnosticsChanged' && diagnosticsCallback) {
+            diagnosticsCallback(params[0] as string)
+          }
+        },
+      })
+
+      // Perform handshake
+      transport
+        .sendRequest('_handshake', [])
+        .then((raw) => {
+          if (settled) return
+          const handshakeResult = raw as { methods: string[] }
+          const availableMethods = handshakeResult.methods
+
+          // Validate required methods
+          if (
+            !availableMethods.includes('fileAccess.readFile') ||
+            !availableMethods.includes('fileAccess.readDirectory')
+          ) {
+            transport.destroy()
+            throw new Error(
+              'Server missing required methods: fileAccess.readFile, fileAccess.readDirectory',
+            )
+          }
+
+          // Build proxy capabilities
+          const capabilities = {} as IdeCapabilities
+
+          for (const { providerKey, methods } of PROVIDER_METHODS) {
+            const present = methods.filter((m) =>
+              availableMethods.includes(`${providerKey}.${m}`),
+            )
+            if (present.length === 0) continue
+
+            const provider: Record<
+              string,
+              (...args: unknown[]) => Promise<unknown>
+            > = {}
+            for (const method of present) {
+              provider[method] = (...args: unknown[]) =>
+                transport.sendRequest(`${providerKey}.${method}`, args)
+            }
+            ;(capabilities as unknown as Record<string, unknown>)[providerKey] =
+              provider
+          }
+
+          // Handle onDiagnosticsChanged
+          if (availableMethods.includes('onDiagnosticsChanged')) {
+            capabilities.onDiagnosticsChanged = (callback) => {
+              diagnosticsCallback = callback
+            }
+          }
+
+          settled = true
+          resolve({
+            capabilities,
+            availableMethods,
+            disconnect() {
+              transport.destroy()
+            },
+          })
+        })
+        .catch((err: unknown) => {
+          if (!settled) {
+            settled = true
+            transport.destroy()
+            reject(err instanceof Error ? err : new Error(String(err)))
+          }
+        })
+    })
+  })
+}