@lsproxy/proxy 0.2.0

package/src/client-session.ts

@@ -0,0 +1,199 @@
+// apps/proxy/src/client-session.ts
+import { extname } from 'node:path';
+import type { Transport } from '@lspeasy/core';
+import type { LSPClient } from '@lspeasy/client';
+import type { BackendPool } from './backend-pool.js';
+import type { DocumentStateManager } from './document-state.js';
+
+export interface ClientSessionOptions {
+  sessionId: string;
+  transport: Transport;
+  pool: BackendPool;
+  docState: DocumentStateManager;
+  root: string;
+  onEnd: (sessionId: string) => void;
+}
+
+type RawMsg = {
+  jsonrpc: '2.0';
+  id?: string | number | null;
+  method?: string;
+  params?: unknown;
+  result?: unknown;
+  error?: unknown;
+};
+
+export class ClientSession {
+  private readonly id: string;
+  private readonly transport: Transport;
+  private readonly pool: BackendPool;
+  private readonly docState: DocumentStateManager;
+  private readonly onEnd: (sessionId: string) => void;
+  private languageId = 'plaintext';
+  private requestIdCounter = 0;
+  private readonly pendingClientRequests = new Map<string | number, (result: unknown) => void>();
+  private applyEditDisposable: { dispose(): void } | undefined;
+
+  constructor(opts: ClientSessionOptions) {
+    this.id = opts.sessionId;
+    this.transport = opts.transport;
+    this.pool = opts.pool;
+    this.docState = opts.docState;
+    this.onEnd = opts.onEnd;
+
+    this.transport.onMessage((msg) => this.handleMessage(msg as unknown as RawMsg));
+    this.transport.onClose(() => this.handleClose());
+    this.transport.onError((e) => process.stderr.write(`[session:${this.id}] ${e.message}\n`));
+  }
+
+  private async handleMessage(msg: RawMsg): Promise<void> {
+    const isRequest = msg.id !== undefined && msg.method !== undefined;
+    const isNotification = msg.id === undefined && msg.method !== undefined;
+    // Response to a request we sent (e.g. workspace/applyEdit forwarded to CLI)
+    const isResponse = msg.id !== undefined && msg.method === undefined && msg.result !== undefined;
+
+    if (isResponse) {
+      const resolve = this.pendingClientRequests.get(msg.id as string | number);
+      if (resolve) {
+        this.pendingClientRequests.delete(msg.id as string | number);
+        resolve(msg.result);
+      }
+      return;
+    }
+
+    try {
+      if (isRequest) {
+        const result = await this.handleRequest(msg);
+        await this.transport.send({
+          jsonrpc: '2.0',
+          id: msg.id as string | number,
+          result
+        });
+      } else if (isNotification) {
+        await this.handleNotification(msg);
+      }
+    } catch (err) {
+      if (isRequest) {
+        await this.transport.send({
+          jsonrpc: '2.0',
+          id: msg.id as string | number,
+          error: { code: -32603, message: String(err) }
+        });
+      }
+    }
+  }
+
+  private async forwardToClient(method: string, params: unknown): Promise<unknown> {
+    const id = ++this.requestIdCounter;
+    return new Promise((resolve) => {
+      this.pendingClientRequests.set(id, resolve);
+      void this.transport.send({ jsonrpc: '2.0', id, method, params });
+    });
+  }
+
+  private async handleRequest(msg: RawMsg): Promise<unknown> {
+    if (msg.method === 'initialize') {
+      return this.handleInitialize(msg.params as Record<string, unknown>);
+    }
+    if (msg.method === 'shutdown') {
+      // Ack without tearing down the shared backend
+      return null;
+    }
+    const backend = this.backendForMsg(msg);
+    return (backend.sendRequest as (m: string, p: unknown) => Promise<unknown>)(
+      msg.method!,
+      msg.params
+    );
+  }
+
+  private async handleInitialize(params: Record<string, unknown>): Promise<unknown> {
+    const initOpts = params['initializationOptions'] as Record<string, unknown> | undefined;
+    this.languageId = (initOpts?.['languageId'] as string | undefined) ?? 'plaintext';
+    const backend = await this.pool.ensureBackend(this.languageId);
+
+    // Forward workspace/applyEdit from backend to this CLI session.
+    // The registration overwrites any prior session's handler — acceptable because
+    // applyEdit only fires during executeCommand, which is driven by an active session.
+    this.applyEditDisposable?.dispose();
+    this.applyEditDisposable = (
+      backend.onRequest as (m: string, h: (p: unknown) => Promise<unknown>) => { dispose(): void }
+    )('workspace/applyEdit', (p) => this.forwardToClient('workspace/applyEdit', p));
+
+    return { capabilities: backend.getServerCapabilities() ?? {} };
+  }
+
+  private async handleNotification(msg: RawMsg): Promise<void> {
+    // Session lifecycle — not forwarded to the shared backend
+    if (msg.method === 'initialized' || msg.method === 'exit') return;
+
+    if (msg.method === 'textDocument/didOpen') {
+      const p = msg.params as Record<string, unknown>;
+      const td = p['textDocument'] as Record<string, unknown>;
+      const uri = td['uri'] as string;
+      const content = td['text'] as string;
+      const langId = td['languageId'] as string;
+      const action = this.docState.onDidOpen(this.id, uri, content, langId);
+
+      const backend = await this.pool.ensureBackend(langId || this.languageIdForUri(uri));
+
+      if (action === 'open') {
+        await (backend.sendNotification as (m: string, p: unknown) => Promise<void>)(
+          'textDocument/didOpen',
+          p
+        );
+      } else if (action === 'change') {
+        await (backend.sendNotification as (m: string, p: unknown) => Promise<void>)(
+          'textDocument/didChange',
+          {
+            textDocument: { uri, version: (td['version'] as number) + 1 },
+            contentChanges: [{ text: content }]
+          }
+        );
+      }
+      // 'skip' → no-op
+      return;
+    }
+
+    if (msg.method === 'textDocument/didClose') {
+      const p = msg.params as Record<string, unknown>;
+      const td = p['textDocument'] as Record<string, unknown>;
+      const uri = td['uri'] as string;
+      this.docState.onDidClose(this.id, uri);
+      return;
+    }
+
+    // Forward all other notifications (didChange, willSave, etc.)
+    const backend = this.backendForMsg(msg);
+    await (backend.sendNotification as (m: string, p: unknown) => Promise<void>)(
+      msg.method!,
+      msg.params
+    );
+  }
+
+  private backendForMsg(msg: RawMsg): LSPClient {
+    // Prefer routing by URI extension; fall back to session's primary languageId
+    const params = msg.params as Record<string, unknown> | undefined;
+    const td = params?.['textDocument'] as Record<string, unknown> | undefined;
+    const uri = td?.['uri'] as string | undefined;
+    const langId = uri ? (this.languageIdForUri(uri) ?? this.languageId) : this.languageId;
+    const backend = this.pool.getBackend(langId) ?? this.pool.getBackend(this.languageId);
+    if (!backend) throw new Error(`No backend available for languageId "${langId}"`);
+    return backend;
+  }
+
+  private languageIdForUri(uri: string): string {
+    try {
+      const ext = extname(new URL(uri).pathname);
+      return this.pool.getLanguageIdForExtension(ext) ?? this.languageId;
+    } catch {
+      return this.languageId;
+    }
+  }
+
+  private handleClose(): void {
+    this.applyEditDisposable?.dispose();
+    this.applyEditDisposable = undefined;
+    this.docState.onSessionEnd(this.id);
+    this.onEnd(this.id);
+  }
+}

package/src/document-state.test.ts

@@ -0,0 +1,64 @@
+// apps/proxy/src/document-state.test.ts
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { DocumentStateManager } from './document-state.js';
+
+describe('DocumentStateManager', () => {
+  afterEach(() => vi.useRealTimers());
+
+  it('returns "open" for a new URI', () => {
+    const m = new DocumentStateManager();
+    expect(m.onDidOpen('session-1', 'file:///a.ts', 'hello', 'typescript')).toBe('open');
+  });
+
+  it('returns "skip" when a second session opens the same URI with same content', () => {
+    const m = new DocumentStateManager();
+    m.onDidOpen('session-1', 'file:///a.ts', 'hello', 'typescript');
+    expect(m.onDidOpen('session-2', 'file:///a.ts', 'hello', 'typescript')).toBe('skip');
+  });
+
+  it('returns "change" when a second session opens URI with different content', () => {
+    const m = new DocumentStateManager();
+    m.onDidOpen('session-1', 'file:///a.ts', 'hello', 'typescript');
+    expect(m.onDidOpen('session-2', 'file:///a.ts', 'world', 'typescript')).toBe('change');
+  });
+
+  it('onSessionEnd returns URIs that had last session closed', () => {
+    const m = new DocumentStateManager();
+    m.onDidOpen('s1', 'file:///a.ts', 'code', 'typescript');
+    m.onDidOpen('s1', 'file:///b.ts', 'code', 'typescript');
+    m.onDidOpen('s2', 'file:///a.ts', 'code', 'typescript');
+    const uris = m.onSessionEnd('s1');
+    // b.ts lost its only session, a.ts still has s2
+    expect(uris).toEqual(['file:///b.ts']);
+  });
+
+  it('cancels lazy-close timer when URI is reopened', () => {
+    vi.useFakeTimers();
+    const closeCallback = vi.fn();
+    const m = new DocumentStateManager({ lazyCloseMs: 1000, onClose: closeCallback });
+    m.onDidOpen('s1', 'file:///a.ts', 'x', 'typescript');
+    m.onSessionEnd('s1'); // schedules lazy close
+    m.onDidOpen('s2', 'file:///a.ts', 'x', 'typescript'); // should cancel timer
+    vi.advanceTimersByTime(2000);
+    expect(closeCallback).not.toHaveBeenCalled();
+  });
+
+  it('fires onClose callback after lazyCloseMs when no sessions remain', () => {
+    vi.useFakeTimers();
+    const closeCallback = vi.fn();
+    const m = new DocumentStateManager({ lazyCloseMs: 500, onClose: closeCallback });
+    m.onDidOpen('s1', 'file:///a.ts', 'x', 'typescript');
+    m.onSessionEnd('s1');
+    vi.advanceTimersByTime(600);
+    expect(closeCallback).toHaveBeenCalledWith('file:///a.ts');
+  });
+
+  it('getContent returns undefined after lazy eviction fires', () => {
+    vi.useFakeTimers();
+    const m = new DocumentStateManager({ lazyCloseMs: 500 });
+    m.onDidOpen('s1', 'file:///a.ts', 'content', 'typescript');
+    m.onSessionEnd('s1');
+    vi.advanceTimersByTime(600);
+    expect(m.getContent('file:///a.ts')).toBeUndefined();
+  });
+});

package/src/document-state.ts

@@ -0,0 +1,92 @@
+// apps/proxy/src/document-state.ts
+import { createHash } from 'node:crypto';
+
+export type DidOpenAction = 'open' | 'change' | 'skip';
+
+export interface DocumentStateOptions {
+  lazyCloseMs?: number;
+  onClose?: (uri: string) => void;
+}
+
+interface DocEntry {
+  languageId: string;
+  content: string;
+  contentHash: string;
+  openSessions: Set<string>;
+  closeTimer?: ReturnType<typeof setTimeout>;
+}
+
+export class DocumentStateManager {
+  private readonly docs = new Map<string, DocEntry>();
+  private readonly lazyCloseMs: number;
+  private readonly onClose: ((uri: string) => void) | undefined;
+
+  constructor(opts: DocumentStateOptions = {}) {
+    this.lazyCloseMs = opts.lazyCloseMs ?? 300_000;
+    this.onClose = opts.onClose;
+  }
+
+  onDidOpen(sessionId: string, uri: string, content: string, languageId: string): DidOpenAction {
+    const hash = createHash('sha256').update(content).digest('hex');
+    const entry = this.docs.get(uri);
+
+    if (!entry) {
+      this.docs.set(uri, {
+        languageId,
+        content,
+        contentHash: hash,
+        openSessions: new Set([sessionId])
+      });
+      return 'open';
+    }
+
+    if (entry.closeTimer !== undefined) {
+      clearTimeout(entry.closeTimer);
+      delete entry.closeTimer;
+    }
+
+    entry.openSessions.add(sessionId);
+
+    if (entry.contentHash === hash) return 'skip';
+
+    entry.content = content;
+    entry.contentHash = hash;
+    return 'change';
+  }
+
+  onDidClose(sessionId: string, uri: string): void {
+    const entry = this.docs.get(uri);
+    if (!entry) return;
+    entry.openSessions.delete(sessionId);
+    if (entry.openSessions.size === 0) {
+      this.scheduleLazyClose(uri, entry);
+    }
+  }
+
+  // Returns URIs where this session was the last opener (informational).
+  // The actual backend didClose fires via onClose after lazyCloseMs — do NOT
+  // forward didClose immediately based on this return value.
+  onSessionEnd(sessionId: string): string[] {
+    const toClose: string[] = [];
+    for (const [uri, entry] of this.docs) {
+      if (!entry.openSessions.has(sessionId)) continue;
+      entry.openSessions.delete(sessionId);
+      if (entry.openSessions.size === 0) {
+        toClose.push(uri);
+        this.scheduleLazyClose(uri, entry);
+      }
+    }
+    return toClose;
+  }
+
+  getContent(uri: string): string | undefined {
+    return this.docs.get(uri)?.content;
+  }
+
+  private scheduleLazyClose(uri: string, entry: DocEntry): void {
+    entry.closeTimer = setTimeout(() => {
+      this.docs.delete(uri);
+      this.onClose?.(uri);
+    }, this.lazyCloseMs);
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { socketPath, pidPath } from './socket-path.js';

package/src/main.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// apps/proxy/src/main.ts
+import { parseArgs } from 'node:util';
+import { resolve } from 'node:path';
+import { ProxyServer } from './proxy-server.js';
+
+const { values } = parseArgs({
+  options: {
+    root: { type: 'string' },
+    socket: { type: 'string' },
+    'idle-timeout': { type: 'string', default: '1800000' },
+    'backend-idle-timeout': { type: 'string', default: '600000' },
+    'lazy-close-delay': { type: 'string', default: '300000' }
+  },
+  allowPositionals: false,
+  strict: true
+});
+
+if (!values['root']) {
+  process.stderr.write('[lsproxy] fatal: --root is required\n');
+  process.exit(1);
+}
+const root = resolve(values['root']);
+const server = new ProxyServer({
+  root,
+  ...(values['socket'] !== undefined && { socketOverride: values['socket'] }),
+  idleTimeoutMs: Number(values['idle-timeout']),
+  backendIdleMs: Number(values['backend-idle-timeout']),
+  lazyCloseMs: Number(values['lazy-close-delay'])
+});
+
+server.start().catch((err: Error) => {
+  process.stderr.write(`[lsproxy] fatal: ${err.message}\n`);
+  process.exit(1);
+});

package/src/proxy-server.ts

@@ -0,0 +1,158 @@
+// apps/proxy/src/proxy-server.ts
+import { createServer, createConnection, type Server, type Socket } from 'node:net';
+import { writeFileSync, unlinkSync, existsSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { socketToTransport } from '@lspeasy/core/node';
+import { BackendPool, type BackendPoolOptions } from './backend-pool.js';
+import { DocumentStateManager } from './document-state.js';
+import { ClientSession } from './client-session.js';
+import { socketPath, pidPath } from './socket-path.js';
+
+export interface ProxyServerOptions extends BackendPoolOptions {
+  root: string;
+  socketOverride?: string;
+  idleTimeoutMs?: number;
+  lazyCloseMs?: number;
+}
+
+export class ProxyServer {
+  private readonly root: string;
+  private readonly sockPath: string;
+  private readonly pidFilePath: string;
+  private readonly idleTimeoutMs: number;
+  private readonly pool: BackendPool;
+  private readonly docState: DocumentStateManager;
+  private server: Server | undefined;
+  private readonly sessions = new Map<string, ClientSession>();
+  private readonly activeSockets = new Set<Socket>();
+  private idleTimer: ReturnType<typeof setTimeout> | undefined;
+  private sessionCounter = 0;
+
+  constructor(opts: ProxyServerOptions) {
+    this.root = opts.root;
+    this.sockPath = opts.socketOverride ?? socketPath(opts.root);
+    this.pidFilePath = opts.socketOverride
+      ? opts.socketOverride.endsWith('.sock')
+        ? opts.socketOverride.slice(0, -5) + '.pid'
+        : opts.socketOverride + '.pid'
+      : pidPath(opts.root);
+    this.idleTimeoutMs = opts.idleTimeoutMs ?? 1_800_000;
+    this.pool = new BackendPool(opts.root, {
+      ...(opts.backendIdleMs !== undefined && { backendIdleMs: opts.backendIdleMs })
+    });
+    this.docState = new DocumentStateManager({
+      ...(opts.lazyCloseMs !== undefined && { lazyCloseMs: opts.lazyCloseMs }),
+      onClose: (uri) => this.lazyCloseUri(uri)
+    });
+  }
+
+  async start(): Promise<void> {
+    mkdirSync(dirname(this.sockPath), { recursive: true });
+
+    const srv = createServer((socket) => {
+      this.activeSockets.add(socket);
+      socket.on('close', () => this.activeSockets.delete(socket));
+      const sessionId = `s${++this.sessionCounter}`;
+      const transport = socketToTransport(socket);
+      const session = new ClientSession({
+        sessionId,
+        transport,
+        pool: this.pool,
+        docState: this.docState,
+        root: this.root,
+        onEnd: (id) => this.onSessionEnd(id)
+      });
+      this.sessions.set(sessionId, session);
+      this.resetIdleTimer();
+    });
+
+    this.server = srv;
+    await new Promise<void>((resolve, reject) => {
+      srv.on('error', async (err: NodeJS.ErrnoException) => {
+        if (err.code === 'EADDRINUSE') {
+          const live = await this.isSocketLive(this.sockPath);
+          if (live) {
+            process.stderr.write('[lsproxy] socket already in use — another daemon is running\n');
+            process.exit(0);
+          }
+          // Stale socket from a crashed daemon — remove and retry once
+          unlinkSync(this.sockPath);
+          srv.listen(this.sockPath, resolve);
+        } else {
+          reject(err);
+        }
+      });
+      srv.listen(this.sockPath, resolve);
+    });
+
+    writeFileSync(this.pidFilePath, String(process.pid), 'utf8');
+    process.stderr.write(`[lsproxy] listening on ${this.sockPath}\n`);
+
+    process.on('SIGTERM', () => this.stop());
+    this.resetIdleTimer();
+  }
+
+  async stop(): Promise<void> {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = undefined;
+    }
+    await this.pool.stopAll();
+    for (const sock of this.activeSockets) sock.destroy();
+    await new Promise<void>((resolve) => {
+      if (!this.server) {
+        resolve();
+        return;
+      }
+      this.server.close(() => resolve());
+    });
+    if (existsSync(this.sockPath)) unlinkSync(this.sockPath);
+    if (existsSync(this.pidFilePath)) unlinkSync(this.pidFilePath);
+  }
+
+  private onSessionEnd(sessionId: string): void {
+    this.sessions.delete(sessionId);
+    this.resetIdleTimer();
+  }
+
+  private resetIdleTimer(): void {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    if (this.sessions.size > 0) return;
+    this.idleTimer = setTimeout(() => {
+      process.stderr.write('[lsproxy] idle timeout — shutting down\n');
+      this.stop().then(() => process.exit(0));
+    }, this.idleTimeoutMs);
+  }
+
+  private isSocketLive(sockPath: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      const sock = createConnection({ path: sockPath });
+      sock.once('connect', () => {
+        sock.destroy();
+        resolve(true);
+      });
+      sock.once('error', () => resolve(false));
+    });
+  }
+
+  private async lazyCloseUri(uri: string): Promise<void> {
+    const ext = (() => {
+      try {
+        return new URL(uri).pathname.split('.').pop() ?? '';
+      } catch {
+        return '';
+      }
+    })();
+    const langId = ext ? this.pool.getLanguageIdForExtension(`.${ext}`) : undefined;
+    const backend = langId ? this.pool.getBackend(langId) : undefined;
+    if (!backend) return;
+    try {
+      await (backend.sendNotification as (m: string, p: unknown) => Promise<void>)(
+        'textDocument/didClose',
+        { textDocument: { uri } }
+      );
+    } catch {
+      // ignore
+    }
+  }
+}

package/src/socket-path.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { socketPath, pidPath } from './socket-path.js';
+import { homedir } from 'node:os';
+import { join, basename } from 'node:path';
+
+describe('socketPath + pidPath', () => {
+  it('produces a stable path for a given root', () => {
+    expect(socketPath('/home/user/myproject')).toBe(socketPath('/home/user/myproject'));
+  });
+
+  it('produces different paths for different roots', () => {
+    expect(socketPath('/project/a')).not.toBe(socketPath('/project/b'));
+  });
+
+  it('path ends with .sock', () => {
+    expect(socketPath('/project')).toMatch(/\.sock$/);
+  });
+
+  it('path is inside ~/.lsproxy/', () => {
+    const base = join(homedir(), '.lsproxy');
+    expect(socketPath('/project')).toContain(base);
+  });
+
+  it('pidPath matches socketPath with .pid extension', () => {
+    const root = '/project';
+    expect(pidPath(root)).toBe(socketPath(root).replace('.sock', '.pid'));
+  });
+
+  it('hash is 12 characters long', () => {
+    const path = socketPath('/project');
+    const hash = basename(path, '.sock');
+    expect(hash).toHaveLength(12);
+  });
+});

package/src/socket-path.ts

@@ -0,0 +1,15 @@
+import { createHash } from 'node:crypto';
+import { resolve, join } from 'node:path';
+import { homedir } from 'node:os';
+
+function rootHash(root: string): string {
+  return createHash('sha1').update(resolve(root)).digest('hex').slice(0, 12);
+}
+
+export function socketPath(root: string): string {
+  return join(homedir(), '.lsproxy', `${rootHash(root)}.sock`);
+}
+
+export function pidPath(root: string): string {
+  return join(homedir(), '.lsproxy', `${rootHash(root)}.pid`);
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declarationMap": true
+  },
+  "references": [{ "path": "../../packages/core" }, { "path": "../../packages/client" }],
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules", "**/*.test.ts", "**/*.spec.ts"]
+}