chainlesschain 0.162.148 → 0.162.149

package/src/lib/lsp/__tests__/lsp-client.test.js

@@ -0,0 +1,258 @@
+/**
+ * LSPClient tests — JSON-RPC handshake, request/response correlation,
+ * notification dispatch, timeouts and crash propagation. A fake child process
+ * is injected through `_deps.spawn`; no real language server is spawned.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { EventEmitter } from "events";
+import {
+  LSPClient,
+  _deps,
+  pathToFileUri,
+  fileUriToPath,
+  normalizeUri,
+  buildSpawnCommand,
+} from "../lsp-client.js";
+import { encodeMessage, MessageBuffer } from "../jsonrpc-stream.js";
+
+/** A fake language server process. Auto-replies to `initialize`; test controls the rest. */
+class FakeChild extends EventEmitter {
+  constructor({ autoInit = true } = {}) {
+    super();
+    this.stdout = new EventEmitter();
+    this.stderr = new EventEmitter();
+    this._inbound = new MessageBuffer();
+    this.received = [];
+    this.killed = false;
+    // Arrow keeps `this` bound to the FakeChild (no this-alias needed).
+    this.stdin = {
+      writable: true,
+      write: (buf) => {
+        this._inbound.append(buf);
+        for (const msg of this._inbound.readAll()) {
+          this.received.push(msg);
+          if (autoInit && msg.method === "initialize") {
+            this.reply(msg.id, { capabilities: { definitionProvider: true } });
+          }
+        }
+        return true;
+      },
+    };
+  }
+  reply(id, result) {
+    this.stdout.emit("data", encodeMessage({ jsonrpc: "2.0", id, result }));
+  }
+  replyError(id, error) {
+    this.stdout.emit("data", encodeMessage({ jsonrpc: "2.0", id, error }));
+  }
+  notify(method, params) {
+    this.stdout.emit("data", encodeMessage({ jsonrpc: "2.0", method, params }));
+  }
+  kill() {
+    this.killed = true;
+  }
+}
+
+let origSpawn;
+beforeEach(() => {
+  origSpawn = _deps.spawn;
+});
+afterEach(() => {
+  _deps.spawn = origSpawn;
+  vi.restoreAllMocks();
+});
+
+function makeClient(child, opts = {}) {
+  _deps.spawn = vi.fn(() => child);
+  return new LSPClient({
+    command: "fake-lsp",
+    args: ["--stdio"],
+    rootPath: "/proj",
+    ...opts,
+  });
+}
+
+describe("LSPClient handshake", () => {
+  it("spawns, sends initialize, and captures server capabilities", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    const caps = await client.start();
+    expect(caps).toEqual({ definitionProvider: true });
+    expect(client.running).toBe(true);
+    // sent initialize then initialized notification
+    expect(child.received[0].method).toBe("initialize");
+    expect(child.received[1].method).toBe("initialized");
+    // spawn used shell:false
+    expect(_deps.spawn).toHaveBeenCalledWith(
+      "fake-lsp",
+      ["--stdio"],
+      expect.objectContaining({ shell: false }),
+    );
+  });
+});
+
+describe("LSPClient request/response", () => {
+  it("correlates a request to its response by id", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    const p = client.request("textDocument/definition", { x: 1 });
+    // server replies to the definition request (id follows initialize=1 → 2)
+    const req = child.received.find(
+      (m) => m.method === "textDocument/definition",
+    );
+    child.reply(req.id, [
+      {
+        uri: "file:///proj/a.ts",
+        range: {
+          start: { line: 0, character: 0 },
+          end: { line: 0, character: 3 },
+        },
+      },
+    ]);
+    const result = await p;
+    expect(result[0].uri).toBe("file:///proj/a.ts");
+  });
+
+  it("rejects a request whose response carries an error", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    const p = client.request("bad/method", {});
+    const req = child.received.find((m) => m.method === "bad/method");
+    child.replyError(req.id, { code: -32601, message: "method not found" });
+    await expect(p).rejects.toThrow(/method not found/);
+  });
+
+  it("times out a request with no response", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    await expect(
+      client.request("slow/op", {}, { timeoutMs: 20 }),
+    ).rejects.toThrow(/timed out/);
+  });
+});
+
+describe("LSPClient notifications", () => {
+  it("emits server notifications by method", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    const got = vi.fn();
+    client.on("notify:textDocument/publishDiagnostics", got);
+    child.notify("textDocument/publishDiagnostics", {
+      uri: "file:///proj/a.ts",
+      diagnostics: [],
+    });
+    expect(got).toHaveBeenCalledWith({
+      uri: "file:///proj/a.ts",
+      diagnostics: [],
+    });
+  });
+
+  it("auto-replies null to server→client requests so the server never blocks", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    child.stdout.emit(
+      "data",
+      encodeMessage({
+        jsonrpc: "2.0",
+        id: 999,
+        method: "workspace/configuration",
+        params: {},
+      }),
+    );
+    const reply = child.received.find((m) => m.id === 999 && m.method == null);
+    expect(reply).toEqual({ jsonrpc: "2.0", id: 999, result: null });
+  });
+});
+
+describe("LSPClient lifecycle", () => {
+  it("fails all pending requests when the process exits", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    const p = client.request("op", {});
+    child.emit("exit", 1, null);
+    await expect(p).rejects.toThrow(/exited|stopped/);
+    expect(client.running).toBe(false);
+  });
+
+  it("stop() shuts down gracefully and is idempotent", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    // auto-reply to shutdown
+    child.stdin.write = (buf) => {
+      const mb = new MessageBuffer().append(buf);
+      for (const m of mb.readAll()) {
+        child.received.push(m);
+        if (m.method === "shutdown") child.reply(m.id, null);
+      }
+      return true;
+    };
+    await client.stop();
+    await client.stop(); // no throw second time
+    expect(child.killed).toBe(true);
+  });
+});
+
+describe("uri <-> path", () => {
+  it("round-trips a POSIX path", () => {
+    expect(fileUriToPath(pathToFileUri("/home/u/a b.ts"))).toBe(
+      process.platform === "win32" ? "\\home\\u\\a b.ts" : "/home/u/a b.ts",
+    );
+  });
+  it("builds a windows drive URI", () => {
+    expect(pathToFileUri("C:\\proj\\a.ts")).toBe("file:///C%3A/proj/a.ts");
+  });
+});
+
+describe("normalizeUri", () => {
+  it("lowercases the windows drive letter so client/server keys match", () => {
+    // path.resolve yields C:, servers echo c: — must collapse to one key
+    expect(normalizeUri("file:///C%3A/proj/a.ts")).toBe(
+      "file:///c%3A/proj/a.ts",
+    );
+    expect(normalizeUri("file:///c%3A/proj/a.ts")).toBe(
+      "file:///c%3A/proj/a.ts",
+    );
+    expect(normalizeUri("file:///C:/proj/a.ts")).toBe("file:///c:/proj/a.ts");
+  });
+  it("leaves POSIX file URIs unchanged", () => {
+    expect(normalizeUri("file:///home/u/a.ts")).toBe("file:///home/u/a.ts");
+  });
+});
+
+describe("buildSpawnCommand", () => {
+  const isWin = process.platform === "win32";
+  it("passes non-batch commands through verbatim", () => {
+    const spec = buildSpawnCommand("/usr/bin/gopls", []);
+    expect(spec).toEqual({
+      file: "/usr/bin/gopls",
+      args: [],
+      windowsVerbatimArguments: false,
+    });
+  });
+  it.runIf(isWin)(
+    "routes a .cmd shim through cmd.exe /d /s /c with a quoted path",
+    () => {
+      const spec = buildSpawnCommand(
+        "C:\\proj\\node_modules\\.bin\\typescript-language-server.cmd",
+        ["--stdio"],
+      );
+      expect(spec.windowsVerbatimArguments).toBe(true);
+      expect(spec.args.slice(0, 3)).toEqual(["/d", "/s", "/c"]);
+      expect(spec.args[3]).toBe(
+        '"C:\\proj\\node_modules\\.bin\\typescript-language-server.cmd" --stdio',
+      );
+    },
+  );
+  it.runIf(isWin)("quotes a path containing spaces", () => {
+    const spec = buildSpawnCommand("C:\\Program Files\\svr.cmd", []);
+    expect(spec.args[3]).toBe('"C:\\Program Files\\svr.cmd"');
+  });
+});

package/src/lib/lsp/__tests__/lsp-manager.test.js

@@ -0,0 +1,264 @@
+/**
+ * LSPManager tests — server pooling, document open/change sync, diagnostics
+ * collection, and position conversion. A fake client is injected via
+ * `_deps.createClient`; the registry resolves a server via `_deps.existsSync`.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { EventEmitter } from "events";
+import path from "path";
+import {
+  LSPManager,
+  toLspPosition,
+  fromLspPosition,
+  _deps,
+} from "../lsp-manager.js";
+import { _deps as regDeps } from "../lsp-server-registry.js";
+
+/** Minimal fake LSPClient: records notifications, canned requests, emits events. */
+class FakeClient extends EventEmitter {
+  constructor(opts) {
+    super();
+    this.rootPath = opts.rootPath;
+    this.running = true;
+    this.notifications = [];
+    this.started = false;
+  }
+  async start() {
+    this.started = true;
+    return { definitionProvider: true };
+  }
+  notify(method, params) {
+    this.notifications.push({ method, params });
+  }
+  async request() {
+    return null;
+  }
+  async stop() {
+    this.running = false;
+  }
+}
+
+let origCreate, origRead, origExistsMgr, origExistsReg;
+let lastClient;
+
+beforeEach(() => {
+  origCreate = _deps.createClient;
+  origRead = _deps.readFileSync;
+  origExistsMgr = _deps.existsSync;
+  origExistsReg = regDeps.existsSync;
+
+  _deps.createClient = (opts) => {
+    lastClient = new FakeClient(opts);
+    return lastClient;
+  };
+  _deps.readFileSync = () => "const x = 1;\n";
+  // root inference: pretend the nearest /proj ancestor has package.json.
+  // Suffix match tolerates path.resolve prepending a drive letter on Windows.
+  _deps.existsSync = (p) =>
+    String(p).replace(/\\/g, "/").endsWith("/proj/package.json");
+  // registry: pretend the TS server bin exists in <root>/node_modules/.bin
+  const isWin = process.platform === "win32";
+  const binName = isWin
+    ? "typescript-language-server.cmd"
+    : "typescript-language-server";
+  regDeps.existsSync = (p) =>
+    String(p).replace(/\\/g, "/").endsWith(`/node_modules/.bin/${binName}`);
+});
+
+afterEach(() => {
+  _deps.createClient = origCreate;
+  _deps.readFileSync = origRead;
+  _deps.existsSync = origExistsMgr;
+  regDeps.existsSync = origExistsReg;
+  vi.restoreAllMocks();
+});
+
+describe("position helpers", () => {
+  it("converts 1-based ⇄ 0-based", () => {
+    expect(toLspPosition({ line: 1, col: 1 })).toEqual({
+      line: 0,
+      character: 0,
+    });
+    expect(toLspPosition({ line: 10, col: 5 })).toEqual({
+      line: 9,
+      character: 4,
+    });
+    expect(fromLspPosition({ line: 0, character: 0 })).toEqual({
+      line: 1,
+      col: 1,
+    });
+    expect(fromLspPosition({ line: 9, character: 4 })).toEqual({
+      line: 10,
+      col: 5,
+    });
+  });
+  it("clamps below 1 to 0 (no negatives to the server)", () => {
+    expect(toLspPosition({ line: 0, col: 0 })).toEqual({
+      line: 0,
+      character: 0,
+    });
+  });
+});
+
+describe("ensureFor", () => {
+  it("starts a server and sends didOpen the first time", async () => {
+    const mgr = new LSPManager();
+    const ready = await mgr.ensureFor("/proj/src/a.ts");
+    expect(ready.languageId).toBe("typescript");
+    expect(ready.root.replace(/\\/g, "/")).toMatch(/\/proj$/);
+    expect(lastClient.started).toBe(true);
+    const open = lastClient.notifications.find(
+      (n) => n.method === "textDocument/didOpen",
+    );
+    expect(open.params.textDocument.text).toBe("const x = 1;\n");
+    await mgr.disposeAll();
+  });
+
+  it("sends didChange (not a second didOpen) on the next access", async () => {
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    await mgr.ensureFor("/proj/src/a.ts");
+    const opens = lastClient.notifications.filter(
+      (n) => n.method === "textDocument/didOpen",
+    );
+    const changes = lastClient.notifications.filter(
+      (n) => n.method === "textDocument/didChange",
+    );
+    expect(opens).toHaveLength(1);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].params.textDocument.version).toBe(2);
+    await mgr.disposeAll();
+  });
+
+  it("reuses one server for two files in the same project/language", async () => {
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    const first = lastClient;
+    await mgr.ensureFor("/proj/src/b.ts");
+    expect(lastClient).toBe(first); // same client instance
+    expect(mgr.activeServerCount).toBe(1);
+    await mgr.disposeAll();
+  });
+
+  it("returns unavailable for an unsupported extension", async () => {
+    const mgr = new LSPManager();
+    const ready = await mgr.ensureFor("/proj/readme.txt");
+    expect(ready.unavailable).toBe(true);
+    expect(ready.reason).toMatch(/no language mapping/);
+    await mgr.disposeAll();
+  });
+
+  it("returns unavailable when no server bin is installed", async () => {
+    regDeps.existsSync = () => false; // nothing installed
+    const mgr = new LSPManager();
+    const ready = await mgr.ensureFor("/proj/src/a.ts");
+    expect(ready.unavailable).toBe(true);
+    expect(ready.reason).toMatch(/no language server installed/);
+    await mgr.disposeAll();
+  });
+});
+
+describe("crash-loop restart guard", () => {
+  // Simulate a language server process dying: the client marks itself not
+  // running and emits `exit`, exactly as the real LSPClient does on child exit.
+  function crash(client) {
+    client.running = false;
+    client.emit("exit", 1, null);
+  }
+
+  it("re-spawns a crashed server on the next request (auto-restart)", async () => {
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    const first = lastClient;
+    crash(first);
+    const ready = await mgr.ensureFor("/proj/src/a.ts");
+    expect(ready.unavailable).toBeUndefined();
+    expect(lastClient).not.toBe(first); // a FRESH client was spawned
+    expect(lastClient.started).toBe(true);
+    expect(ready.client).toBe(lastClient);
+    await mgr.disposeAll();
+  });
+
+  it("quarantines a server that crash-loops past maxRestarts within the window", async () => {
+    let t = 1000;
+    const mgr = new LSPManager({
+      maxRestarts: 3,
+      restartWindowMs: 30000,
+      now: () => t,
+    });
+    for (let i = 0; i < 3; i++) {
+      await mgr.ensureFor("/proj/src/a.ts");
+      t += 100;
+      crash(lastClient);
+    }
+    // 3 crashes are now inside the window → the next request quarantines the
+    // server (degrade to text search) rather than thrash-respawning it.
+    const before = lastClient;
+    const ready = await mgr.ensureFor("/proj/src/a.ts");
+    expect(ready.unavailable).toBe(true);
+    expect(ready.quarantined).toBe(true);
+    expect(ready.reason).toMatch(/crash-looped/);
+    expect(lastClient).toBe(before); // did NOT spawn yet another
+    await mgr.disposeAll();
+  });
+
+  it("recovers and re-spawns once the crash window clears", async () => {
+    let t = 1000;
+    const mgr = new LSPManager({
+      maxRestarts: 3,
+      restartWindowMs: 30000,
+      now: () => t,
+    });
+    for (let i = 0; i < 3; i++) {
+      await mgr.ensureFor("/proj/src/a.ts");
+      t += 100;
+      crash(lastClient);
+    }
+    expect((await mgr.ensureFor("/proj/src/a.ts")).quarantined).toBe(true);
+    // Stay healthy past the window → crash history prunes → a fresh start is
+    // allowed again (a server isn't quarantined forever).
+    t += 30001;
+    const quarantined = lastClient;
+    const ready = await mgr.ensureFor("/proj/src/a.ts");
+    expect(ready.unavailable).toBeUndefined();
+    expect(lastClient).not.toBe(quarantined);
+    await mgr.disposeAll();
+  });
+});
+
+describe("diagnostics", () => {
+  it("collects pushed diagnostics keyed by file", async () => {
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    lastClient.emit("notify:textDocument/publishDiagnostics", {
+      uri: (await import("../lsp-client.js")).pathToFileUri(
+        path.resolve("/proj/src/a.ts"),
+      ),
+      diagnostics: [
+        {
+          message: "boom",
+          severity: 1,
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: 1 },
+          },
+        },
+      ],
+    });
+    const diags = mgr.getDiagnostics("/proj/src/a.ts");
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toBe("boom");
+    await mgr.disposeAll();
+  });
+});
+
+describe("disposeAll", () => {
+  it("stops all servers and blocks further use", async () => {
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    await mgr.disposeAll();
+    expect(lastClient.running).toBe(false);
+    await expect(mgr.ensureFor("/proj/src/a.ts")).rejects.toThrow(/disposed/);
+  });
+});

package/src/lib/lsp/__tests__/lsp-server-registry.test.js

@@ -0,0 +1,128 @@
+/**
+ * lsp-server-registry tests — language mapping, bin resolution (project-local
+ * wins over PATH), plugin server registration, and availability probing. FS
+ * existence is faked via `_deps.existsSync`; no real toolchain needed.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import path from "path";
+import {
+  languageIdForFile,
+  resolveServer,
+  resolveBin,
+  probeServers,
+  registerLanguageServer,
+  _resetPluginServers,
+  _deps,
+} from "../lsp-server-registry.js";
+
+let origExists;
+beforeEach(() => {
+  origExists = _deps.existsSync;
+  _resetPluginServers();
+});
+afterEach(() => {
+  _deps.existsSync = origExists;
+  _resetPluginServers();
+});
+
+/** existsSync true only for the given absolute paths (normalized separators). */
+function existsFor(paths) {
+  const set = new Set(paths.map((p) => p.replace(/\\/g, "/")));
+  _deps.existsSync = (p) => set.has(String(p).replace(/\\/g, "/"));
+}
+
+describe("languageIdForFile", () => {
+  it("maps common extensions", () => {
+    expect(languageIdForFile("a.ts")).toBe("typescript");
+    expect(languageIdForFile("a.TSX")).toBe("typescriptreact");
+    expect(languageIdForFile("a.py")).toBe("python");
+    expect(languageIdForFile("a.go")).toBe("go");
+    expect(languageIdForFile("a.rs")).toBe("rust");
+  });
+  it("returns null for unsupported extensions", () => {
+    expect(languageIdForFile("a.txt")).toBeNull();
+    expect(languageIdForFile("noext")).toBeNull();
+  });
+});
+
+describe("resolveBin", () => {
+  it("prefers project node_modules/.bin over PATH", () => {
+    const isWin = process.platform === "win32";
+    const binName = isWin
+      ? "typescript-language-server.cmd"
+      : "typescript-language-server";
+    const localBin = path.join("/proj", "node_modules", ".bin", binName);
+    existsFor([localBin]);
+    const resolved = resolveBin("typescript-language-server", "/proj");
+    expect(resolved.replace(/\\/g, "/")).toBe(localBin.replace(/\\/g, "/"));
+  });
+
+  it("returns null when nothing resolves", () => {
+    existsFor([]);
+    expect(resolveBin("nonexistent-server", "/proj")).toBeNull();
+  });
+});
+
+describe("resolveServer", () => {
+  it("resolves a TS server command with --stdio args", () => {
+    const isWin = process.platform === "win32";
+    const binName = isWin
+      ? "typescript-language-server.cmd"
+      : "typescript-language-server";
+    existsFor([path.join("/proj", "node_modules", ".bin", binName)]);
+    const s = resolveServer("typescript", "/proj");
+    expect(s).toMatchObject({
+      languageId: "typescript",
+      id: "typescript-language-server",
+      args: ["--stdio"],
+    });
+    expect(s.command).toContain("typescript-language-server");
+  });
+
+  it("returns null for a language with no installed server", () => {
+    existsFor([]);
+    expect(resolveServer("rust", "/proj")).toBeNull();
+  });
+
+  it("returns null for an unknown language", () => {
+    existsFor([]);
+    expect(resolveServer("cobol", "/proj")).toBeNull();
+  });
+});
+
+describe("plugin server registration", () => {
+  it("registers an extra language server and its extensions", () => {
+    registerLanguageServer({
+      languageId: "zig",
+      extensions: [".zig"],
+      command: "zls",
+      args: [],
+    });
+    expect(languageIdForFile("a.zig")).toBe("zig");
+    const isWin = process.platform === "win32";
+    existsFor([
+      path.join("/proj", "node_modules", ".bin", isWin ? "zls.cmd" : "zls"),
+    ]);
+    const s = resolveServer("zig", "/proj");
+    expect(s).toMatchObject({ id: "zls" });
+  });
+
+  it("rejects an incomplete registration", () => {
+    expect(() => registerLanguageServer({ languageId: "x" })).toThrow(
+      /requires/,
+    );
+  });
+});
+
+describe("probeServers", () => {
+  it("reports availability per server family", () => {
+    existsFor([]); // nothing installed
+    const rows = probeServers("/proj");
+    expect(rows.every((r) => r.available === false)).toBe(true);
+    // one row per distinct server id (TS family collapses)
+    const ids = rows.map((r) => r.id);
+    expect(new Set(ids).size).toBe(ids.length);
+    expect(ids).toContain("typescript-language-server");
+  });
+});