@lsproxy/proxy 0.2.0 → 1.0.0

package/src/document-state.ts

@@ -1,92 +0,0 @@
-// 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

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

package/src/main.ts

@@ -1,35 +0,0 @@
-#!/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

@@ -1,158 +0,0 @@
-// 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

@@ -1,34 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,12 +0,0 @@
-{
-  "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"]
-}