micro-models-agent 0.51.2 → 0.52.0

package/dist/modules/lsp/client.js

@@ -0,0 +1,389 @@
+import { spawn, execSync } from "child_process";
+import { resolve } from "path";
+import { platform } from "os";
+import { resolveSpawnCommand, buildWinCommandLine } from "./command";
+import { killTree } from "../processes/registry";
+/**
+ * Logger adapter that writes LSP diagnostics to app.jsonl only — never to
+ * console/terminal. LSP warnings are noisy (timeout on first run, npx
+ * install) and should be diagnosable from session files without polluting
+ * the user's chat.
+ */
+export class FileOnlyLogger {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    debug(msg, meta) {
+        this.logger.logSilent("debug", msg, meta);
+    }
+    info(msg, meta) {
+        this.logger.logSilent("info", msg, meta);
+    }
+    warn(msg, meta) {
+        this.logger.logSilent("warn", msg, meta);
+    }
+    error(msg, meta) {
+        this.logger.logSilent("error", msg, meta);
+    }
+}
+const DEFAULT_TIMEOUT = 15000;
+export class LspClient {
+    logger = null;
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    process = null;
+    requestId = 0;
+    pending = new Map();
+    buffer = "";
+    contentLength = -1;
+    diagnostics = [];
+    diagnosticsResolve = null;
+    diagnosticsTimer = null;
+    initialized = false;
+    async checkFile(filePath, baseDir, config, projectRoot = baseDir) {
+        const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+        try {
+            await this.initialize(config, projectRoot, timeout);
+            this.sendNotification("initialized", {});
+            const uri = this.pathToUri(resolve(filePath));
+            const fs = await import("fs");
+            const content = fs.readFileSync(filePath, "utf-8");
+            const diagPromise = new Promise((resolve) => {
+                this.diagnosticsResolve = resolve;
+                this.diagnostics = [];
+                this.diagnosticsTimer = setTimeout(() => {
+                    this.diagnosticsResolve?.([]);
+                    this.diagnosticsResolve = null;
+                }, timeout);
+            });
+            this.sendNotification("textDocument/didOpen", {
+                textDocument: {
+                    uri,
+                    languageId: this.languageFromPath(filePath),
+                    version: 1,
+                    text: content,
+                },
+            });
+            return await diagPromise;
+        }
+        catch (e) {
+            // Re-throw so the LspModule can surface failures instead of hiding them.
+            throw e instanceof Error ? e : new Error(String(e));
+        }
+        finally {
+            await this.shutdown();
+        }
+    }
+    /**
+     * Lightweight "does the server actually start" probe: spawn + initialize +
+     * shutdown. Used by the REPL banner to surface a dead server (npx
+     * auto-install failure, wrong package name, missing binary) up front instead
+     * of the first write_file timing out.
+     */
+    async probe(config, projectRoot, timeout) {
+        try {
+            await this.initialize(config, projectRoot, timeout);
+        }
+        finally {
+            await this.shutdown();
+        }
+    }
+    async initialize(config, projectRoot, timeout) {
+        await this.startServer(config, projectRoot);
+        const rootUri = this.pathToUri(projectRoot);
+        const initParams = {
+            processId: process.pid,
+            rootUri,
+            workspaceFolders: [{ uri: rootUri, name: "workspace" }],
+            capabilities: { textDocument: { publishDiagnostics: {} } },
+        };
+        try {
+            await this.sendRequest("initialize", initParams, timeout);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            this.logger?.warn(`LSP initialize failed (attempt 1): ${msg}`, {
+                command: config.command,
+                projectRoot,
+            });
+            // npx auto-install can blow past the initialize timeout on first run — retry once.
+            if (!(e instanceof Error) || !e.message.includes("initialize"))
+                throw e;
+            await this.shutdown();
+            await this.startServer(config, projectRoot);
+            try {
+                await this.sendRequest("initialize", initParams, timeout);
+            }
+            catch (retryErr) {
+                const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+                this.logger?.error(`LSP initialize failed (attempt 2, giving up): ${retryMsg}`, {
+                    command: config.command,
+                    projectRoot,
+                });
+                throw retryErr;
+            }
+        }
+        this.initialized = true;
+    }
+    async startServer(config, projectRoot) {
+        if (config.autoInstall === false) {
+            try {
+                execSync(`where ${config.command}`, { stdio: "pipe", timeout: 3000 });
+            }
+            catch {
+                throw new Error(`${config.command} not found in PATH`);
+            }
+        }
+        // When the command is npx, try to find the actual binary globally first.
+        // npx downloads packages on every invocation (slow on Windows, ~8-15s),
+        // even when the binary is already installed globally.
+        let effectiveCommand = config.command;
+        let effectiveArgs = config.args ?? [];
+        if (config.command === "npx" && effectiveArgs.length > 0) {
+            const binaryName = this.extractBinaryFromNpxArgs(effectiveArgs);
+            if (binaryName) {
+                const whichCmd = platform() === "win32" ? `where ${binaryName}` : `which ${binaryName}`;
+                try {
+                    execSync(whichCmd, { stdio: "pipe", timeout: 3000 });
+                    // Binary found globally — use it directly, skip npx.
+                    effectiveCommand = binaryName;
+                    effectiveArgs = effectiveArgs.filter((a) => a !== "--yes" && a !== "--package" && a !== binaryName && !this.isPackageVersion(a));
+                    this.logger?.debug(`LSP: using globally installed ${binaryName} (skipped npx)`);
+                }
+                catch {
+                    // Not found globally — fall back to npx (will auto-install).
+                    this.logger?.debug(`LSP: ${binaryName} not found globally, falling back to npx`);
+                }
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const args = effectiveArgs;
+            const isWin = platform() === "win32";
+            let spawnCommand = resolveSpawnCommand(effectiveCommand);
+            let spawnArgs = args;
+            const spawnOpts = {
+                stdio: ["pipe", "pipe", "pipe"],
+                env: { ...process.env, ...config.env },
+                cwd: projectRoot,
+            };
+            if (isWin) {
+                // A `.cmd` shim can't be spawned directly under Node (`spawn npx EINVAL`) — run via cmd.exe.
+                spawnCommand = buildWinCommandLine(spawnCommand, args);
+                spawnArgs = [];
+                spawnOpts.shell = true;
+            }
+            const proc = spawn(spawnCommand, spawnArgs, spawnOpts);
+            proc.on("error", reject);
+            proc.stdout.on("data", (chunk) => {
+                this.handleData(chunk);
+            });
+            proc.stderr.on("data", () => { });
+            proc.once("spawn", () => {
+                resolve();
+            });
+            this.process = proc;
+            setTimeout(() => {
+                if (!this.initialized && this.process) {
+                    const msg = "LSP server start timeout";
+                    this.logger?.error(msg, { command: config.command, projectRoot, timeout: config.timeout ?? 10000 });
+                    reject(new Error(msg));
+                }
+            }, config.timeout ?? 10000);
+        });
+    }
+    handleData(chunk) {
+        this.buffer += chunk.toString();
+        this.parseMessages();
+    }
+    parseMessages() {
+        while (true) {
+            if (this.contentLength === -1) {
+                const headerEnd = this.buffer.indexOf("\r\n\r\n");
+                if (headerEnd === -1)
+                    return;
+                const header = this.buffer.slice(0, headerEnd);
+                const match = header.match(/Content-Length: (\d+)/i);
+                if (!match) {
+                    this.buffer = this.buffer.slice(headerEnd + 4);
+                    this.contentLength = -1;
+                    continue;
+                }
+                this.contentLength = parseInt(match[1], 10);
+                // Guard against malicious/buggy servers sending absurd Content-Length
+                if (this.contentLength > 10 * 1024 * 1024) {
+                    this.buffer = this.buffer.slice(headerEnd + 4);
+                    this.contentLength = -1;
+                    continue;
+                }
+                this.buffer = this.buffer.slice(headerEnd + 4);
+            }
+            if (this.buffer.length < this.contentLength)
+                return;
+            const body = this.buffer.slice(0, this.contentLength);
+            this.buffer = this.buffer.slice(this.contentLength);
+            this.contentLength = -1;
+            try {
+                const msg = JSON.parse(body);
+                this.handleMessage(msg);
+            }
+            catch (e) {
+                this.logger?.debug(`LSP JSON parse error: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+    }
+    handleMessage(msg) {
+        if (msg.method === "textDocument/publishDiagnostics") {
+            const params = msg.params;
+            if (params?.diagnostics) {
+                this.diagnostics = params.diagnostics;
+                if (this.diagnosticsTimer) {
+                    clearTimeout(this.diagnosticsTimer);
+                    this.diagnosticsTimer = null;
+                }
+                this.diagnosticsResolve?.(this.diagnostics);
+                this.diagnosticsResolve = null;
+            }
+            return;
+        }
+        if (msg.id !== undefined && msg.id !== null) {
+            const pending = this.pending.get(msg.id);
+            if (pending) {
+                this.pending.delete(msg.id);
+                if (msg.error) {
+                    pending.reject(new Error(String(msg.error.message ?? "LSP error")));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+        }
+    }
+    sendRequest(method, params, timeout) {
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestId;
+            this.pending.set(id, { resolve, reject });
+            const message = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+            this.write(message);
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    const msg = `LSP request timeout: ${method}`;
+                    this.logger?.warn(msg, { method, timeout });
+                    reject(new Error(msg));
+                }
+            }, timeout);
+        });
+    }
+    sendNotification(method, params) {
+        const message = JSON.stringify({ jsonrpc: "2.0", method, params });
+        this.write(message);
+    }
+    write(message) {
+        if (!this.process?.stdin?.writable) {
+            this.logger?.debug("LSP write failed: process stdin not writable");
+            return;
+        }
+        const header = `Content-Length: ${Buffer.byteLength(message)}\r\n\r\n`;
+        try {
+            this.process.stdin.write(header + message);
+        }
+        catch (e) {
+            this.logger?.debug(`LSP write error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    async shutdown() {
+        try {
+            if (this.process && this.initialized && this.process.stdin?.writable) {
+                // Await the shutdown response (with timeout) so the server has time to
+                // acknowledge before we send exit and kill the process.  The old code
+                // fired shutdown as fire-and-forget, then killed immediately — the
+                // server never had a chance to reply, producing spurious timeout warnings.
+                try {
+                    await this.sendRequest("shutdown", null, 3000);
+                }
+                catch (e) {
+                    this.logger?.debug(`LSP shutdown request failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                this.sendNotification("exit", null);
+                await new Promise((r) => setTimeout(r, 200));
+            }
+        }
+        catch (e) {
+            this.logger?.debug(`LSP shutdown error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        finally {
+            if (this.process) {
+                // The direct child on win32 is the cmd.exe wrapper; killing it alone
+                // orphans the npx → node → tsserver tree (observed as leaked node
+                // processes after every check). Tree-kill so the whole chain dies.
+                try {
+                    killTree(this.process);
+                }
+                catch (e) {
+                    this.logger?.debug(`LSP killTree error: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                this.process = null;
+            }
+            this.initialized = false;
+            this.buffer = "";
+            this.contentLength = -1;
+            if (this.diagnosticsTimer) {
+                clearTimeout(this.diagnosticsTimer);
+                this.diagnosticsTimer = null;
+            }
+        }
+    }
+    pathToUri(filePath) {
+        const normalized = filePath.replace(/\\/g, "/");
+        return /^[a-zA-Z]:/.test(normalized) ? `file:///${normalized}` : `file://${normalized}`;
+    }
+    languageFromPath(filePath) {
+        const ext = filePath.split(".").pop()?.toLowerCase();
+        const map = {
+            ts: "typescript",
+            tsx: "typescriptreact",
+            mts: "typescript",
+            cts: "typescript",
+            js: "javascript",
+            jsx: "javascriptreact",
+            mjs: "javascript",
+            cjs: "javascript",
+            py: "python",
+            go: "go",
+            rs: "rust",
+            json: "json",
+            html: "html",
+            css: "css",
+            scss: "scss",
+            md: "markdown",
+            yaml: "yaml",
+            yml: "yaml",
+        };
+        return map[ext ?? ""] ?? "plaintext";
+    }
+    /**
+     * Extract the actual binary name from npx args.
+     * For `npx --yes --package typescript-language-server --package typescript@5 typescript-language-server --stdio`
+     * returns `typescript-language-server` (the last non-flag arg before `--stdio`).
+     */
+    extractBinaryFromNpxArgs(args) {
+        // Find the binary: last arg that doesn't start with -- and isn't a package version
+        for (let i = args.length - 1; i >= 0; i--) {
+            const arg = args[i];
+            if (arg === "--stdio")
+                continue;
+            if (arg.startsWith("--"))
+                return null; // unexpected format
+            if (this.isPackageVersion(arg))
+                continue;
+            return arg;
+        }
+        return null;
+    }
+    /** Check if a string looks like a package version specifier (e.g. "typescript@5"). */
+    isPackageVersion(s) {
+        return /^[\w-]+@[\d.+*-]/.test(s);
+    }
+}

package/dist/modules/lsp/command.js

@@ -0,0 +1,60 @@
+import { delimiter, join } from "path";
+import { existsSync } from "fs";
+import { platform } from "os";
+const WIN_EXTS = [".cmd", ".bat", ".exe", ".com"];
+/**
+ * Resolve the command string passed to `child_process.spawn` on Windows.
+ *
+ * Node's `spawn` cannot execute `.cmd`/`.bat` shims directly without a shell,
+ * and a bare `npx` fails with `spawn npx ENOENT` because on Windows the
+ * real executable is `npx.cmd`. This returns the first existing shim
+ * (`npx.cmd`, `npx.bat`, `npx.exe`, ...) found on PATH, or the bare command
+ * when nothing exists (the spawn will then fail with a meaningful ENOENT).
+ *
+ * Non-Windows platforms and commands that already carry an extension or a
+ * path separator are returned unchanged.
+ */
+export function resolveSpawnCommand(command, platformName = platform(), pathEnv = process.env.PATH ?? "") {
+    if (platformName !== "win32")
+        return command;
+    // Already a path or has an extension — pass through.
+    if (command.includes("/") ||
+        command.includes("\\") ||
+        WIN_EXTS.some((ext) => command.toLowerCase().endsWith(ext))) {
+        return command;
+    }
+    const dirs = pathEnv.split(delimiter).filter(Boolean);
+    for (const dir of dirs) {
+        for (const ext of WIN_EXTS) {
+            const candidate = join(dir, `${command}${ext}`);
+            if (existsSync(candidate))
+                return `${command}${ext}`;
+        }
+    }
+    return command;
+}
+/**
+ * Join a resolved command and its args into a single cmd.exe command line.
+ *
+ * Under Node on Windows, `spawn` of a `.cmd`/`.bat` shim WITHOUT a shell throws
+ * `spawn EINVAL` (CreateProcess cannot run batch files directly). Resolving
+ * `npx` → `npx.cmd` fixes the old `ENOENT` but not the `EINVAL` — the spawn
+ * still has no shell. The reliable fix is to run the whole command line through
+ * `cmd.exe /d /s /c` (i.e. `spawn(line, { shell: true })`). This helper builds
+ * that line, quoting any argument that contains cmd.exe metacharacters so the
+ * package names and flags in LSP configs (`typescript-language-server --stdio`,
+ * `pyright --stdio`) survive the round-trip.
+ *
+ * Non-Windows platforms never call this (they spawn the resolved command +
+ * args directly, no shell).
+ */
+export function buildWinCommandLine(command, args) {
+    const quote = (part) => {
+        if (part === "")
+            return '""';
+        if (!/[\s"&|^<>()%!]/.test(part))
+            return part;
+        return `"${part.replace(/"/g, '\\"')}"`;
+    };
+    return [command, ...args].map(quote).join(" ");
+}

package/dist/modules/lsp/config.js

@@ -0,0 +1,135 @@
+/**
+ * LSP server defaults.
+ *
+ * Strategy: prefer `npx` (auto-downloads) over globally installed binaries.
+ * Servers using system tools (rust-analyzer, gopls) have `autoInstall: false`
+ * and are skipped silently when not found.
+ */
+export const DEFAULT_LSP_CONFIG = {
+    enabled: true,
+    timeout: 15000,
+    servers: {
+        typescript: {
+            command: "npx",
+            args: [
+                "--yes",
+                "--package",
+                "typescript-language-server",
+                "--package",
+                "typescript@5",
+                "typescript-language-server",
+                "--stdio",
+            ],
+            timeout: 30000,
+            autoInstall: true,
+            workspaceMarkers: ["package.json", "tsconfig.json"],
+        },
+        javascript: {
+            command: "npx",
+            args: [
+                "--yes",
+                "--package",
+                "typescript-language-server",
+                "--package",
+                "typescript@5",
+                "typescript-language-server",
+                "--stdio",
+            ],
+            timeout: 30000,
+            autoInstall: true,
+            workspaceMarkers: ["package.json", "tsconfig.json"],
+        },
+        python: {
+            command: "npx",
+            args: ["pyright", "--stdio"],
+            timeout: 15000,
+            autoInstall: true,
+            workspaceMarkers: ["pyproject.toml", "setup.py", "requirements.txt"],
+        },
+        rust: {
+            command: "rust-analyzer",
+            timeout: 15000,
+            autoInstall: false,
+            workspaceMarkers: ["Cargo.toml"],
+        },
+        go: {
+            command: "gopls",
+            timeout: 15000,
+            autoInstall: false,
+            workspaceMarkers: ["go.mod"],
+        },
+        json: {
+            command: "npx",
+            args: [
+                "--yes",
+                "--package",
+                "vscode-langservers-extracted",
+                "vscode-json-language-server",
+                "--stdio",
+            ],
+            timeout: 30000,
+            autoInstall: true,
+            workspaceMarkers: ["package.json"],
+        },
+        html: {
+            command: "npx",
+            args: [
+                "--yes",
+                "--package",
+                "vscode-langservers-extracted",
+                "--package",
+                "typescript@5",
+                "vscode-html-language-server",
+                "--stdio",
+            ],
+            timeout: 60000,
+            autoInstall: true,
+            workspaceMarkers: ["package.json"],
+        },
+        css: {
+            command: "npx",
+            args: [
+                "--yes",
+                "--package",
+                "vscode-langservers-extracted",
+                "--package",
+                "typescript@5",
+                "vscode-css-language-server",
+                "--stdio",
+            ],
+            timeout: 60000,
+            autoInstall: true,
+            workspaceMarkers: ["package.json"],
+        },
+    },
+};
+const LANGUAGE_MAP = {
+    ts: "typescript",
+    tsx: "typescript",
+    mts: "typescript",
+    cts: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    py: "python",
+    rs: "rust",
+    go: "go",
+    json: "json",
+    html: "html",
+    css: "css",
+    scss: "css",
+};
+/** Language id for a file extension (via LANGUAGE_MAP), or null when unsupported. */
+export function getLanguageForFile(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    if (!ext)
+        return null;
+    return LANGUAGE_MAP[ext] ?? null;
+}
+export function getServerForFile(filePath, config) {
+    const lang = getLanguageForFile(filePath);
+    if (!lang)
+        return null;
+    return config.servers[lang] ?? null;
+}

package/dist/modules/lsp/index.js

@@ -0,0 +1,3 @@
+export { LspModule } from "./module";
+export { LspClient, FileOnlyLogger } from "./client";
+export { getServerForFile, DEFAULT_LSP_CONFIG } from "./config";