oh-my-opencode 4.10.0 → 4.11.0

package/packages/lsp-tools-mcp/dist/lsp/process.js

@@ -1,153 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
-import { delimiter, join } from "node:path";
-import { reportBestEffortCleanupError } from "./cleanup-errors.js";
-import { LspInvalidPathError, LspProcessSpawnError } from "./errors.js";
-function isMissingProcessError(error) {
-    if (!(error instanceof Error) || !("code" in error))
-        return false;
-    return error.code === "ESRCH";
-}
-function reportKillError(context, error) {
-    if (!isMissingProcessError(error)) {
-        reportBestEffortCleanupError(context, error);
-    }
-}
-export function validateCwd(cwd) {
-    try {
-        if (!existsSync(cwd)) {
-            return { valid: false, error: `Working directory does not exist: ${cwd}` };
-        }
-        const stats = statSync(cwd);
-        if (!stats.isDirectory()) {
-            return { valid: false, error: `Path is not a directory: ${cwd}` };
-        }
-        return { valid: true };
-    }
-    catch (err) {
-        return {
-            valid: false,
-            error: `Cannot access working directory: ${cwd} (${err instanceof Error ? err.message : String(err)})`,
-        };
-    }
-}
-function wrap(proc) {
-    const exitedPromise = new Promise((resolve) => {
-        proc.once("close", (code) => resolve(code ?? 0));
-        proc.once("error", () => resolve(1));
-    });
-    if (!proc.stdin || !proc.stdout || !proc.stderr) {
-        throw new LspProcessSpawnError("Spawned process is missing one of stdin/stdout/stderr pipes");
-    }
-    return {
-        stdin: proc.stdin,
-        stdout: proc.stdout,
-        stderr: proc.stderr,
-        get pid() {
-            return proc.pid ?? undefined;
-        },
-        get exitCode() {
-            return proc.exitCode;
-        },
-        get killed() {
-            return proc.killed;
-        },
-        exited: exitedPromise,
-        kill(signal) {
-            killProcessTree(proc, signal ?? "SIGTERM");
-        },
-    };
-}
-function killProcessTree(proc, signal) {
-    if (process.platform === "win32" && proc.pid) {
-        const result = spawnSync("taskkill", ["/pid", String(proc.pid), "/f", "/t"], { stdio: "ignore" });
-        if (!result.error && result.status === 0)
-            return;
-        if (result.error)
-            reportKillError("windows process tree kill", result.error);
-    }
-    if (process.platform !== "win32" && proc.pid) {
-        try {
-            process.kill(-proc.pid, signal);
-            return;
-        }
-        catch (error) {
-            reportKillError("process group kill", error);
-        }
-    }
-    try {
-        proc.kill(signal);
-    }
-    catch (error) {
-        reportKillError("process kill", error);
-    }
-}
-function isWindowsShellShim(command) {
-    const lowerCommand = command.toLowerCase();
-    return lowerCommand.endsWith(".cmd") || lowerCommand.endsWith(".bat");
-}
-function splitPath(pathValue, platform) {
-    const separator = platform === "win32" ? ";" : delimiter;
-    return pathValue.split(separator).filter(Boolean);
-}
-function getWindowsPathExtensions(env) {
-    const rawExtensions = env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD";
-    const extensions = rawExtensions
-        .split(";")
-        .map((extension) => extension.trim())
-        .filter(Boolean)
-        .map((extension) => (extension.startsWith(".") ? extension : `.${extension}`));
-    return [...new Set([...extensions, ".exe", ".cmd", ".bat", ""])];
-}
-function resolveWindowsCommand(command, env) {
-    const hasPathSeparator = command.includes("/") || command.includes("\\");
-    const pathValue = env["PATH"] ?? env["Path"] ?? "";
-    const baseDirectories = hasPathSeparator ? [""] : splitPath(pathValue, "win32");
-    const extensions = getWindowsPathExtensions(env);
-    for (const baseDirectory of baseDirectories) {
-        for (const extension of extensions) {
-            const candidate = baseDirectory ? join(baseDirectory, `${command}${extension}`) : `${command}${extension}`;
-            if (existsSync(candidate))
-                return candidate;
-        }
-    }
-    return command;
-}
-export function createSpawnCommand(command, platform = process.platform, commandProcessor = process.env["ComSpec"] ?? "cmd.exe", env = process.env) {
-    const [cmd, ...args] = command;
-    if (!cmd) {
-        throw new LspProcessSpawnError("[lsp] empty command");
-    }
-    if (platform !== "win32") {
-        return { command: cmd, args, shell: false };
-    }
-    const resolvedCommand = resolveWindowsCommand(cmd, env);
-    if (!isWindowsShellShim(resolvedCommand)) {
-        return { command: resolvedCommand, args, shell: false };
-    }
-    return {
-        command: commandProcessor,
-        args: ["/d", "/s", "/c", resolvedCommand, ...args],
-        shell: false,
-    };
-}
-export function spawnProcess(command, options) {
-    const cwdValidation = validateCwd(options.cwd);
-    if (!cwdValidation.valid) {
-        throw new LspInvalidPathError(`[lsp] ${cwdValidation.error}`);
-    }
-    const [cmd] = command;
-    if (!cmd) {
-        throw new LspProcessSpawnError("[lsp] empty command");
-    }
-    const preparedCommand = createSpawnCommand(command, process.platform, process.env["ComSpec"] ?? "cmd.exe", options.env);
-    const proc = spawn(preparedCommand.command, preparedCommand.args, {
-        cwd: options.cwd,
-        env: options.env,
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-        shell: preparedCommand.shell,
-        detached: process.platform !== "win32",
-    });
-    return wrap(proc);
-}

package/packages/lsp-tools-mcp/dist/lsp/server-definitions.js

@@ -1,170 +0,0 @@
-export const LSP_INSTALL_HINTS = {
-    typescript: "npm install -g typescript-language-server typescript",
-    deno: "Install Deno from https://deno.land",
-    vue: "npm install -g @vue/language-server",
-    eslint: "npm install -g vscode-langservers-extracted",
-    oxlint: "npm install -g oxlint",
-    biome: "npm install -g @biomejs/biome",
-    gopls: "go install golang.org/x/tools/gopls@latest",
-    "ruby-lsp": "gem install ruby-lsp",
-    basedpyright: "pip install basedpyright",
-    pyright: "pip install pyright",
-    ty: "pip install ty",
-    ruff: "pip install ruff",
-    "elixir-ls": "See https://github.com/elixir-lsp/elixir-ls",
-    zls: "See https://github.com/zigtools/zls",
-    csharp: "dotnet tool install -g csharp-ls",
-    fsharp: "dotnet tool install -g fsautocomplete",
-    "sourcekit-lsp": "Included with Xcode or Swift toolchain",
-    rust: "Install rust-analyzer and ensure it is in PATH. If using rustup: rustup component add rust-analyzer. " +
-        "If rust-analyzer exits while loading rust-src: rustup component remove rust-src && rustup component add rust-src.",
-    clangd: "See https://clangd.llvm.org/installation",
-    svelte: "npm install -g svelte-language-server",
-    astro: "npm install -g @astrojs/language-server",
-    "bash-ls": "npm install -g bash-language-server",
-    jdtls: "See https://github.com/eclipse-jdtls/eclipse.jdt.ls",
-    "yaml-ls": "npm install -g yaml-language-server",
-    "lua-ls": "See https://github.com/LuaLS/lua-language-server",
-    php: "npm install -g intelephense",
-    dart: "Included with Dart SDK",
-    "terraform-ls": "See https://github.com/hashicorp/terraform-ls",
-    terraform: "See https://github.com/hashicorp/terraform-ls",
-    prisma: "npm install -g prisma",
-    "ocaml-lsp": "opam install ocaml-lsp-server",
-    texlab: "See https://github.com/latex-lsp/texlab",
-    dockerfile: "npm install -g dockerfile-language-server-nodejs",
-    gleam: "See https://gleam.run/getting-started/installing/",
-    "clojure-lsp": "See https://clojure-lsp.io/installation/",
-    nixd: "nix profile install nixpkgs#nixd",
-    tinymist: "See https://github.com/Myriad-Dreamin/tinymist",
-    "haskell-language-server": "ghcup install hls",
-    bash: "npm install -g bash-language-server",
-    "kotlin-ls": "See https://github.com/Kotlin/kotlin-lsp",
-    julials: "julia -e 'using Pkg; Pkg.add(\"LanguageServer\")'",
-    razor: "Razor runs through the Roslyn language server (cohosting). " +
-        "Install: dotnet tool install -g roslyn-language-server --prerelease (requires v5.8.0+). See https://github.com/dotnet/razor",
-};
-export const BUILTIN_SERVERS = {
-    typescript: {
-        command: ["typescript-language-server", "--stdio"],
-        extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
-    },
-    deno: { command: ["deno", "lsp"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"] },
-    vue: { command: ["vue-language-server", "--stdio"], extensions: [".vue"] },
-    eslint: {
-        command: ["vscode-eslint-language-server", "--stdio"],
-        extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue"],
-    },
-    oxlint: {
-        command: ["oxlint", "--lsp"],
-        extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue", ".astro", ".svelte"],
-    },
-    biome: {
-        command: ["biome", "lsp-proxy", "--stdio"],
-        extensions: [
-            ".ts",
-            ".tsx",
-            ".js",
-            ".jsx",
-            ".mjs",
-            ".cjs",
-            ".mts",
-            ".cts",
-            ".json",
-            ".jsonc",
-            ".vue",
-            ".astro",
-            ".svelte",
-            ".css",
-            ".graphql",
-            ".gql",
-            ".html",
-        ],
-    },
-    gopls: { command: ["gopls"], extensions: [".go"] },
-    "ruby-lsp": {
-        command: ["rubocop", "--lsp"],
-        extensions: [".rb", ".rake", ".gemspec", ".ru"],
-    },
-    basedpyright: {
-        command: ["basedpyright-langserver", "--stdio"],
-        extensions: [".py", ".pyi"],
-    },
-    pyright: { command: ["pyright-langserver", "--stdio"], extensions: [".py", ".pyi"] },
-    ty: { command: ["ty", "server"], extensions: [".py", ".pyi"] },
-    ruff: { command: ["ruff", "server"], extensions: [".py", ".pyi"] },
-    "elixir-ls": { command: ["elixir-ls"], extensions: [".ex", ".exs"] },
-    zls: { command: ["zls"], extensions: [".zig", ".zon"] },
-    csharp: { command: ["csharp-ls"], extensions: [".cs"] },
-    fsharp: { command: ["fsautocomplete"], extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
-    "sourcekit-lsp": { command: ["sourcekit-lsp"], extensions: [".swift", ".m", ".mm"] },
-    rust: { command: ["rust-analyzer"], extensions: [".rs"] },
-    clangd: {
-        command: ["clangd", "--background-index", "--clang-tidy"],
-        extensions: [".c", ".cpp", ".cc", ".cxx", ".c++", ".h", ".hpp", ".hh", ".hxx", ".h++"],
-    },
-    svelte: { command: ["svelteserver", "--stdio"], extensions: [".svelte"] },
-    astro: { command: ["astro-ls", "--stdio"], extensions: [".astro"] },
-    bash: {
-        command: ["bash-language-server", "start"],
-        extensions: [".sh", ".bash", ".zsh", ".ksh"],
-    },
-    "bash-ls": {
-        command: ["bash-language-server", "start"],
-        extensions: [".sh", ".bash", ".zsh", ".ksh"],
-    },
-    jdtls: { command: ["jdtls"], extensions: [".java"] },
-    "yaml-ls": { command: ["yaml-language-server", "--stdio"], extensions: [".yaml", ".yml"] },
-    "lua-ls": { command: ["lua-language-server"], extensions: [".lua"] },
-    php: { command: ["intelephense", "--stdio"], extensions: [".php"] },
-    dart: { command: ["dart", "language-server", "--lsp"], extensions: [".dart"] },
-    terraform: { command: ["terraform-ls", "serve"], extensions: [".tf", ".tfvars"] },
-    "terraform-ls": { command: ["terraform-ls", "serve"], extensions: [".tf", ".tfvars"] },
-    prisma: { command: ["prisma", "language-server"], extensions: [".prisma"] },
-    "ocaml-lsp": { command: ["ocamllsp"], extensions: [".ml", ".mli"] },
-    texlab: { command: ["texlab"], extensions: [".tex", ".bib"] },
-    dockerfile: { command: ["docker-langserver", "--stdio"], extensions: [".dockerfile"] },
-    gleam: { command: ["gleam", "lsp"], extensions: [".gleam"] },
-    "clojure-lsp": {
-        command: ["clojure-lsp", "listen"],
-        extensions: [".clj", ".cljs", ".cljc", ".edn"],
-    },
-    nixd: { command: ["nixd"], extensions: [".nix"] },
-    tinymist: { command: ["tinymist"], extensions: [".typ", ".typc"] },
-    "haskell-language-server": {
-        command: ["haskell-language-server-wrapper", "--lsp"],
-        extensions: [".hs", ".lhs"],
-    },
-    "kotlin-ls": { command: ["kotlin-lsp", "--stdio"], extensions: [".kt", ".kts"] },
-    julials: {
-        command: ["julia", "--startup-file=no", "--history-file=no", "-e", "using LanguageServer; runserver()"],
-        extensions: [".jl"],
-    },
-    razor: {
-        command: ["roslyn-language-server", "--stdio"],
-        extensions: [".razor", ".cshtml"],
-    },
-};
-export const AUTO_INSTALLABLE_SERVERS = {
-    typescript: ["npm", "install", "-g", "typescript-language-server", "typescript"],
-    vue: ["npm", "install", "-g", "@vue/language-server"],
-    eslint: ["npm", "install", "-g", "vscode-langservers-extracted"],
-    oxlint: ["npm", "install", "-g", "oxlint"],
-    biome: ["npm", "install", "-g", "@biomejs/biome"],
-    svelte: ["npm", "install", "-g", "svelte-language-server"],
-    astro: ["npm", "install", "-g", "@astrojs/language-server"],
-    "bash-ls": ["npm", "install", "-g", "bash-language-server"],
-    bash: ["npm", "install", "-g", "bash-language-server"],
-    "yaml-ls": ["npm", "install", "-g", "yaml-language-server"],
-    php: ["npm", "install", "-g", "intelephense"],
-    prisma: ["npm", "install", "-g", "prisma"],
-    dockerfile: ["npm", "install", "-g", "dockerfile-language-server-nodejs"],
-    gopls: ["go", "install", "golang.org/x/tools/gopls@latest"],
-    pyright: ["pip", "install", "pyright"],
-    basedpyright: ["pip", "install", "basedpyright"],
-    ruff: ["pip", "install", "ruff"],
-    ty: ["pip", "install", "ty"],
-    "ruby-lsp": ["gem", "install", "ruby-lsp"],
-    "ocaml-lsp": ["opam", "install", "ocaml-lsp-server"],
-    julials: ["julia", "-e", 'using Pkg; Pkg.add("LanguageServer")'],
-};

package/packages/lsp-tools-mcp/dist/lsp/server-install-state.js

@@ -1,51 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
-import { contextEnv } from "../request-context.js";
-export function getInstallDecisionsPath() {
-    const override = contextEnv("LSP_TOOLS_MCP_INSTALL_DECISIONS");
-    if (!override)
-        return join(homedir(), ".codex", "lsp-install-decisions.json");
-    return isAbsolute(override) ? override : join(homedir(), override);
-}
-export function loadInstallDecisions() {
-    const path = getInstallDecisionsPath();
-    if (!existsSync(path))
-        return {};
-    try {
-        const parsed = JSON.parse(readFileSync(path, "utf8"));
-        return isInstallDecisions(parsed) ? parsed : {};
-    }
-    catch {
-        return {};
-    }
-}
-export function loadInstallDecision(serverId) {
-    return loadInstallDecisions()[serverId];
-}
-export function recordInstallDecision(serverId, decision, decidedAt = new Date().toISOString()) {
-    const decisions = loadInstallDecisions();
-    decisions[serverId] = { decision, decidedAt };
-    writeInstallDecisions(decisions);
-}
-export function isInstallDecision(value) {
-    return value === "declined" || value === "allowed";
-}
-function writeInstallDecisions(decisions) {
-    const path = getInstallDecisionsPath();
-    mkdirSync(dirname(path), { recursive: true });
-    const tmpPath = `${path}.tmp`;
-    writeFileSync(tmpPath, `${JSON.stringify(decisions, null, 2)}\n`, "utf8");
-    renameSync(tmpPath, path);
-}
-function isInstallDecisions(value) {
-    return isRecord(value) && Object.values(value).every(isInstallDecisionRecord);
-}
-function isInstallDecisionRecord(value) {
-    if (!isRecord(value))
-        return false;
-    return isInstallDecision(value["decision"]) && typeof value["decidedAt"] === "string";
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/packages/lsp-tools-mcp/dist/lsp/server-installation.js

@@ -1,40 +0,0 @@
-import { existsSync } from "node:fs";
-import { delimiter, join } from "node:path";
-export function isServerInstalled(command, _workingDirectory) {
-    if (command.length === 0)
-        return false;
-    const [cmd] = command;
-    if (!cmd)
-        return false;
-    if (cmd.includes("/") || cmd.includes("\\")) {
-        if (existsSync(cmd))
-            return true;
-    }
-    const isWindows = process.platform === "win32";
-    let exts = [""];
-    if (isWindows) {
-        const pathExt = process.env["PATHEXT"] ?? "";
-        if (pathExt) {
-            const systemExts = pathExt.split(";").filter(Boolean);
-            exts = [...new Set([...exts, ...systemExts, ".exe", ".cmd", ".bat", ".ps1"])];
-        }
-        else {
-            exts = ["", ".exe", ".cmd", ".bat", ".ps1"];
-        }
-    }
-    let pathEnv = process.env["PATH"] ?? "";
-    if (isWindows && !pathEnv) {
-        pathEnv = process.env["Path"] ?? "";
-    }
-    const paths = pathEnv.split(delimiter);
-    for (const p of paths) {
-        for (const suffix of exts) {
-            if (existsSync(join(p, cmd + suffix))) {
-                return true;
-            }
-        }
-    }
-    if (cmd === "node")
-        return true;
-    return false;
-}

package/packages/lsp-tools-mcp/dist/lsp/server-resolution.js

@@ -1,86 +0,0 @@
-import { getDisabledServerIds, getMergedServers } from "./config-loader.js";
-import { BUILTIN_SERVERS, LSP_INSTALL_HINTS } from "./server-definitions.js";
-import { isServerInstalled } from "./server-installation.js";
-export function findServerForExtension(ext) {
-    const servers = getMergedServers();
-    for (const server of servers) {
-        if (server.extensions.includes(ext) && isServerInstalled(server.command)) {
-            const resolvedServer = {
-                id: server.id,
-                command: server.command,
-                extensions: server.extensions,
-                priority: server.priority,
-            };
-            if (server.env !== undefined) {
-                return {
-                    status: "found",
-                    server: {
-                        ...resolvedServer,
-                        env: server.env,
-                        ...(server.initialization === undefined ? {} : { initialization: server.initialization }),
-                    },
-                };
-            }
-            return {
-                status: "found",
-                server: {
-                    ...resolvedServer,
-                    ...(server.initialization === undefined ? {} : { initialization: server.initialization }),
-                },
-            };
-        }
-    }
-    for (const server of servers) {
-        if (server.extensions.includes(ext)) {
-            const installHint = LSP_INSTALL_HINTS[server.id] ?? `Install '${server.command[0]}' and ensure it's in your PATH`;
-            return {
-                status: "not_installed",
-                server: {
-                    id: server.id,
-                    command: server.command,
-                    extensions: server.extensions,
-                },
-                installHint,
-            };
-        }
-    }
-    const availableServers = [...new Set(servers.map((s) => s.id))];
-    return {
-        status: "not_configured",
-        extension: ext,
-        availableServers,
-    };
-}
-export function getAllServers() {
-    const servers = getMergedServers();
-    const disabled = getDisabledServerIds();
-    const result = [];
-    const seen = new Set();
-    for (const server of servers) {
-        if (seen.has(server.id))
-            continue;
-        result.push({
-            id: server.id,
-            installed: isServerInstalled(server.command),
-            extensions: server.extensions,
-            disabled: false,
-            source: server.source,
-            priority: server.priority,
-        });
-        seen.add(server.id);
-    }
-    for (const id of disabled) {
-        if (seen.has(id))
-            continue;
-        const builtin = BUILTIN_SERVERS[id];
-        result.push({
-            id,
-            installed: builtin ? isServerInstalled(builtin.command) : false,
-            extensions: builtin?.extensions ?? [],
-            disabled: true,
-            source: "disabled",
-            priority: 0,
-        });
-    }
-    return result;
-}

package/packages/lsp-tools-mcp/dist/lsp/startup-failure.js

@@ -1,35 +0,0 @@
-import { LspProcessExitedError } from "./errors.js";
-const RUST_SRC_REPAIR_MESSAGE = [
-    "rust-analyzer exited while loading Rust standard library sources.",
-    "",
-    "Repair rust-src for the active toolchain:",
-    "  rustup component remove rust-src",
-    "  rustup component add rust-src",
-];
-export function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-export function formatKnownLspStartupFailure(error) {
-    if (!(error instanceof LspProcessExitedError))
-        return null;
-    if (error.serverId !== "rust")
-        return null;
-    const details = error.stderrTail ?? error.message;
-    const lowerDetails = details.toLowerCase();
-    const isRustSrcFailure = lowerDetails.includes("rust-src") &&
-        (lowerDetails.includes("failed to install component") ||
-            lowerDetails.includes("detected conflict") ||
-            lowerDetails.includes("can't load standard library") ||
-            lowerDetails.includes("try installing") ||
-            lowerDetails.includes("sysroot"));
-    if (!isRustSrcFailure)
-        return null;
-    return [...RUST_SRC_REPAIR_MESSAGE, "", "Original stderr tail:", details].join("\n");
-}
-export function handleMissingDependencyError(error) {
-    const knownStartupFailure = formatKnownLspStartupFailure(error);
-    if (knownStartupFailure)
-        return knownStartupFailure;
-    const message = errorMessage(error);
-    return message.includes("NOT INSTALLED") || message.includes("No LSP server configured") ? message : null;
-}