@octocodeai/octocode-engine 16.5.1 → 16.6.2

package/dist/lsp/serverDiscovery.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Platformized language-server discovery.
+ *
+ * The native layer (`config.rs`) already resolves explicit overrides
+ * (`OCTOCODE_*_SERVER_PATH`, `.octocode/lsp-servers.json`) and anything on
+ * `PATH` via `which`. This module covers the gap that bites in production: a
+ * server IS installed, but in a per-ecosystem directory that a GUI-launched
+ * IDE's (or a bare `spawn`'s) impoverished `PATH` never sees — `~/.cargo/bin`,
+ * `~/go/bin`, `~/.local/bin`, the npm/pnpm global prefixes, the Neovim `mason`
+ * dir, the Homebrew prefix, version-manager shims, and the per-OS Windows
+ * shim dirs.
+ *
+ * ## Performance (CLI-critical)
+ *
+ * `lsp-server list` calls `discoverServer` for every known server with the
+ * same workspaceRoot, so cold-start cost matters. Three caches work together:
+ *
+ *   1. `_discoveryCache`     — result per `(command, workspaceRoot)`. After the
+ *      first call, every subsequent call for the same pair is O(1): zero fs ops.
+ *
+ *   2. `_existingEcoDirs`    — ecosystem dirs filtered to only those that
+ *      exist on disk. Computed once per process (or after `clearDiscoveryCache`).
+ *      Turns ~15 dirs × N servers into ~15 stats once + only real-dir probes.
+ *
+ *   3. `_projectLocalDirs`   — resolved project-local path lists per workspace
+ *      root (avoids re-walking the directory tree).
+ *
+ * Call `clearDiscoveryCache()` after installing a server mid-session.
+ *
+ * Search order (first hit wins): project-local → known ecosystem dirs →
+ * IDE-bundled extension servers. Returns an absolute path plus a provenance
+ * label, or `null` if nothing on the machine provides the command.
+ */
+export type DiscoverySource = 'project-local' | `ecosystem:${string}` | 'ide-bundled';
+export interface DiscoveredServer {
+    command: string;
+    source: DiscoverySource;
+}
+/**
+ * Invalidate all discovery caches. Call after programmatically installing a
+ * server (e.g. `provisionServer`) or in tests between scenarios.
+ */
+export declare function clearDiscoveryCache(): void;
+/**
+ * Locate `command` on this machine outside of `PATH`. `command` is the bare
+ * server name (e.g. `rust-analyzer`, `gopls`); absolute commands are returned
+ * by the caller before this is reached.
+ *
+ * Results are memoised for the process lifetime. Call `clearDiscoveryCache()`
+ * after installing a server mid-session.
+ */
+export declare function discoverServer(command: string, workspaceRoot: string): DiscoveredServer | null;
+/**
+ * Discover multiple servers in one call, sharing the ecosystem-dir pre-filter
+ * and project-local dir computation across all commands. Results are written
+ * into the shared cache, so subsequent `discoverServer` calls for the same
+ * `(command, workspaceRoot)` pair are O(1).
+ *
+ * Equivalent to calling `discoverServer` for each command individually, but
+ * avoids redundant work when the caller needs results for many commands against
+ * the same workspace (e.g. the `lsp-server list` CLI command).
+ */
+export declare function discoverServerBatch(commands: string[], workspaceRoot: string): Record<string, DiscoveredServer | null>;

package/dist/lsp/serverDiscovery.js

@@ -0,0 +1,226 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { detectIdeContext } from './ideContext.js';
+import { firstExecutableIn } from './platform.js';
+/** Per-command-per-workspace result. `undefined` = not yet looked up. */
+const _discoveryCache = new Map();
+/** Ecosystem dirs that actually exist; `null` = not yet computed. */
+let _existingEcoDirs = null;
+/** Project-local dir lists per resolved workspace root. */
+const _projectLocalDirs = new Map();
+/**
+ * Invalidate all discovery caches. Call after programmatically installing a
+ * server (e.g. `provisionServer`) or in tests between scenarios.
+ */
+export function clearDiscoveryCache() {
+    _discoveryCache.clear();
+    _existingEcoDirs = null;
+    _projectLocalDirs.clear();
+}
+const HOME = homedir();
+const join = path.join;
+function envPath(...segments) {
+    return join(...segments);
+}
+/**
+ * Every ecosystem `bin` directory worth probing on this OS, paired with a
+ * label for provenance. Computed from env vars + canonical defaults — no
+ * subprocess spawning, so it stays cheap to call per resolution.
+ */
+function ecosystemBinDirs() {
+    const env = process.env;
+    const out = [];
+    const add = (dir, label) => {
+        if (dir)
+            out.push({ dir, label });
+    };
+    if (process.platform === 'win32') {
+        const appData = env.APPDATA;
+        const localAppData = env.LOCALAPPDATA;
+        add(env.USERPROFILE && envPath(env.USERPROFILE, '.cargo', 'bin'), 'cargo');
+        add(env.USERPROFILE && envPath(env.USERPROFILE, 'go', 'bin'), 'go');
+        // Go Windows installer default: C:\Go\bin (distinct from %USERPROFILE%\go\bin)
+        add('C:\\Go\\bin', 'go');
+        // LLVM/clangd: official Windows installer defaults
+        add('C:\\Program Files\\LLVM\\bin', 'llvm');
+        add('C:\\Program Files (x86)\\LLVM\\bin', 'llvm');
+        // .NET global tools (csharp-ls, OmniSharp, etc.)
+        add(env.USERPROFILE && envPath(env.USERPROFILE, '.dotnet', 'tools'), 'dotnet');
+        add(appData && envPath(appData, 'npm'), 'npm-global');
+        add(localAppData && envPath(localAppData, 'pnpm'), 'pnpm');
+        add(env.USERPROFILE && envPath(env.USERPROFILE, 'scoop', 'shims'), 'scoop');
+        add(env.ProgramData && envPath(env.ProgramData, 'chocolatey', 'bin'), 'choco');
+        add(localAppData && envPath(localAppData, 'Microsoft', 'WinGet', 'Links'), 'winget');
+        add(localAppData && envPath(localAppData, 'nvim-data', 'mason', 'bin'), 'mason');
+        return out;
+    }
+    // Rust
+    add(envPath(HOME, '.cargo', 'bin'), 'cargo');
+    // Go
+    add(env.GOBIN, 'go');
+    add(env.GOPATH ? envPath(env.GOPATH, 'bin') : undefined, 'go');
+    add(envPath(HOME, 'go', 'bin'), 'go');
+    // Python user installs
+    add(envPath(HOME, '.local', 'bin'), 'python-user');
+    // Node global (env-driven prefixes + canonical defaults)
+    add(env.npm_config_prefix ? envPath(env.npm_config_prefix, 'bin') : undefined, 'npm-global');
+    add(env.PNPM_HOME, 'pnpm');
+    add(envPath(HOME, '.volta', 'bin'), 'volta');
+    add(envPath(HOME, '.asdf', 'shims'), 'asdf');
+    add(envPath(HOME, '.local', 'share', 'mise', 'shims'), 'mise');
+    // Neovim mason (high-value on dev machines)
+    add(envPath(HOME, '.local', 'share', 'nvim', 'mason', 'bin'), 'mason');
+    // Homebrew (Apple Silicon first — the #1 "installed but not found" cause)
+    add('/opt/homebrew/bin', 'homebrew');
+    add('/usr/local/bin', 'homebrew');
+    add('/home/linuxbrew/.linuxbrew/bin', 'homebrew');
+    // System binary dirs: clangd ships in /usr/bin on macOS (Xcode CLI tools) and
+    // on Linux distros that install it via the package manager. Check after homebrew
+    // so a homebrew-managed version takes precedence over the system one.
+    add('/usr/bin', 'system');
+    // macOS framework Python: ~/Library/Python/<X.Y>/bin
+    if (process.platform === 'darwin') {
+        add(envPath(HOME, 'Library', 'Python'), 'python-framework');
+    }
+    // .NET global tools (csharp-ls, OmniSharp, etc.)
+    add(envPath(HOME, '.dotnet', 'tools'), 'dotnet');
+    // Active virtualenv / conda
+    add(env.VIRTUAL_ENV ? envPath(env.VIRTUAL_ENV, 'bin') : undefined, 'venv');
+    add(env.CONDA_PREFIX ? envPath(env.CONDA_PREFIX, 'bin') : undefined, 'conda');
+    return out;
+}
+/**
+ * Ecosystem dirs that exist on this machine, cached for the process lifetime.
+ * Pre-filtering eliminates stat calls for non-existent dirs on every lookup —
+ * on a typical dev machine this shrinks the probe list from ~15 to ~5.
+ */
+function existingEcoDirs() {
+    if (!_existingEcoDirs) {
+        _existingEcoDirs = ecosystemBinDirs().filter(({ dir }) => existsSync(dir));
+    }
+    return _existingEcoDirs;
+}
+/** Project-local server dirs, walking up from the workspace root. */
+function buildProjectLocalDirs(workspaceRoot) {
+    const dirs = [];
+    let current = workspaceRoot; // already resolved by callers
+    for (;;) {
+        dirs.push(join(current, 'node_modules', '.bin'));
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    const venvBin = process.platform === 'win32' ? 'Scripts' : 'bin';
+    dirs.push(join(workspaceRoot, '.venv', venvBin));
+    if (process.env.VIRTUAL_ENV)
+        dirs.push(join(process.env.VIRTUAL_ENV, venvBin));
+    return dirs;
+}
+function cachedProjectLocalDirs(resolvedRoot) {
+    let dirs = _projectLocalDirs.get(resolvedRoot);
+    if (!dirs) {
+        dirs = buildProjectLocalDirs(resolvedRoot);
+        _projectLocalDirs.set(resolvedRoot, dirs);
+    }
+    return dirs;
+}
+/**
+ * VS Code (and fork) extension roots whose `<ext>/server/` dirs may hold a
+ * reusable server. Skipped unless we detect an IDE host.
+ */
+function ideExtensionRoots() {
+    const { isIde, host } = detectIdeContext();
+    if (!isIde)
+        return [];
+    const roots = {
+        vscode: join(HOME, '.vscode', 'extensions'),
+        cursor: join(HOME, '.cursor', 'extensions'),
+        windsurf: join(HOME, '.windsurf', 'extensions'),
+    };
+    const candidates = [roots[host], join(HOME, '.vscode-server', 'extensions')].filter((dir) => Boolean(dir));
+    return candidates.filter(existsSync);
+}
+function resolveCommand(command) {
+    return path.basename(command);
+}
+function resolveRoot(workspaceRoot) {
+    return path.resolve(workspaceRoot);
+}
+function cacheKey(command, resolvedRoot) {
+    return `${command}\0${resolvedRoot}`;
+}
+/**
+ * Core lookup — runs only on cache miss. Assumes `command` is a basename and
+ * `resolvedRoot` is an absolute path.
+ */
+function scan(command, resolvedRoot) {
+    if (!command)
+        return null;
+    // 1) Project-local — matches the project's pinned toolchain.
+    for (const dir of cachedProjectLocalDirs(resolvedRoot)) {
+        const hit = firstExecutableIn(dir, command, join);
+        if (hit)
+            return { command: hit, source: 'project-local' };
+    }
+    // 2) Known ecosystem dirs (pre-filtered to existing).
+    for (const { dir, label } of existingEcoDirs()) {
+        const hit = firstExecutableIn(dir, command, join);
+        if (hit)
+            return { command: hit, source: `ecosystem:${label}` };
+    }
+    // 3) IDE-bundled extension servers (only when hosted in an IDE).
+    for (const root of ideExtensionRoots()) {
+        if (existsSync(root)) {
+            // No safe generic launch — see LSP_GUIDE.md "IDE reuse".
+            break;
+        }
+    }
+    return null;
+}
+/**
+ * Locate `command` on this machine outside of `PATH`. `command` is the bare
+ * server name (e.g. `rust-analyzer`, `gopls`); absolute commands are returned
+ * by the caller before this is reached.
+ *
+ * Results are memoised for the process lifetime. Call `clearDiscoveryCache()`
+ * after installing a server mid-session.
+ */
+export function discoverServer(command, workspaceRoot) {
+    const base = resolveCommand(command);
+    const resolved = resolveRoot(workspaceRoot);
+    const key = cacheKey(base, resolved);
+    if (_discoveryCache.has(key)) {
+        return _discoveryCache.get(key) ?? null;
+    }
+    const result = scan(base, resolved);
+    _discoveryCache.set(key, result);
+    return result;
+}
+/**
+ * Discover multiple servers in one call, sharing the ecosystem-dir pre-filter
+ * and project-local dir computation across all commands. Results are written
+ * into the shared cache, so subsequent `discoverServer` calls for the same
+ * `(command, workspaceRoot)` pair are O(1).
+ *
+ * Equivalent to calling `discoverServer` for each command individually, but
+ * avoids redundant work when the caller needs results for many commands against
+ * the same workspace (e.g. the `lsp-server list` CLI command).
+ */
+export function discoverServerBatch(commands, workspaceRoot) {
+    const resolved = resolveRoot(workspaceRoot);
+    const results = {};
+    for (const command of commands) {
+        const base = resolveCommand(command);
+        const key = cacheKey(base, resolved);
+        if (_discoveryCache.has(key)) {
+            results[command] = _discoveryCache.get(key) ?? null;
+            continue;
+        }
+        const result = scan(base, resolved);
+        _discoveryCache.set(key, result);
+        results[command] = result;
+    }
+    return results;
+}

package/dist/lsp/serverManifest.d.ts

@@ -0,0 +1,70 @@
+import { type PlatformId } from './platform.js';
+/**
+ * Download manifest for portable, toolchain-free language servers (the
+ * AUTO-DOWNLOAD-OK class). `serverManifest.json` is the human-authored source;
+ * `serverManifestData.ts` mirrors it as a TS module so the compiled dist needs
+ * no JSON-copy step. This module is the typed loader + per-platform selector +
+ * managed-cache locator.
+ *
+ * Provisioning policy (see docs/context/LSP_GUIDE.md):
+ *   OCTOCODE_LSP_AUTO_INSTALL = off (default) | prompt | auto
+ * Live network download is gated and requires a pinned `sha256` per asset.
+ * Until SHAs are pinned the manifest still drives (a) honest detect-and-instruct
+ * guidance and (b) reuse of a server a user/CI has pre-populated into the
+ * managed cache `~/.octocode/lsp/<server>/<releaseTag>/<binName>`.
+ */
+export type ArchiveKind = 'none' | 'gz' | 'zip' | 'tar.gz' | 'tar.xz';
+export interface ManifestAsset {
+    url: string;
+    archive: ArchiveKind;
+    binName: string;
+    /** Path of the executable inside the archive (zip/tar); absent for gz/none. */
+    binPath?: string;
+    /** SHA-256 of the downloaded asset; download is refused while this is null. */
+    sha256: string | null;
+}
+export interface ManifestServer {
+    languageId: string;
+    repo: string;
+    releaseTag: string;
+    launchArgs?: string[];
+    downloadHost?: string;
+    platforms: Partial<Record<PlatformId, ManifestAsset>>;
+    unsupportedPlatforms?: Partial<Record<PlatformId, string>>;
+}
+export interface ManifestFile {
+    $comment?: string;
+    version: number;
+    servers: Record<string, ManifestServer>;
+}
+export type ProvisionMode = 'off' | 'prompt' | 'auto';
+/** The configured auto-install policy. Defaults to `prompt` when unset (asks before downloading). Set OCTOCODE_LSP_AUTO_INSTALL=off to disable all downloads, or =auto to skip the prompt. */
+export declare function provisionMode(env?: NodeJS.ProcessEnv): ProvisionMode;
+/** The manifest entry for a server, keyed by its bare command name. */
+export declare function manifestServer(serverName: string): ManifestServer | null;
+/** Every auto-downloadable server in the manifest (for `lsp-server list`). */
+export declare function listManifestServers(): Array<{
+    name: string;
+    languageId: string;
+    releaseTag: string;
+}>;
+/** Whether the manifest can, in principle, auto-provide this server. */
+export declare function isAutoDownloadable(serverName: string): boolean;
+/**
+ * Root of the managed server cache. Defaults to `~/.octocode/lsp` (consistent
+ * with the rest of octocode's home), overridable via `OCTOCODE_LSP_CACHE_DIR`
+ * for read-only/ephemeral sandbox HOMEs or to point at a pre-baked image path.
+ */
+export declare function managedCacheRoot(env?: NodeJS.ProcessEnv): string;
+/** Where a provisioned binary lives once installed/extracted. */
+export declare function cachedServerBinPath(serverName: string, platformId?: PlatformId): string | null;
+/**
+ * If a managed binary is already present AND verified in the cache (downloaded
+ * by a prior run, by CI, or pre-baked), return its absolute path. A binary is
+ * only trusted when its sibling `<binName>.ok` completion marker exists — a
+ * half-written binary from an interrupted install has no marker and is ignored,
+ * so it never resolves as "installed". Read-only — always safe to call.
+ */
+export declare function resolveCachedServer(serverName: string, platformId?: PlatformId): string | null;
+/** Human-readable provisioning guidance for a server with no resolved binary. */
+export declare function manifestInstallHint(serverName: string): string | null;

package/dist/lsp/serverManifest.js

@@ -0,0 +1,78 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { detectPlatformId } from './platform.js';
+import { MANIFEST } from './serverManifestData.js';
+function loadManifest() {
+    return MANIFEST;
+}
+/** The configured auto-install policy. Defaults to `prompt` when unset (asks before downloading). Set OCTOCODE_LSP_AUTO_INSTALL=off to disable all downloads, or =auto to skip the prompt. */
+export function provisionMode(env = process.env) {
+    const raw = (env.OCTOCODE_LSP_AUTO_INSTALL ?? '').trim().toLowerCase();
+    if (raw === 'auto' || raw === 'off')
+        return raw;
+    return 'prompt';
+}
+/** The manifest entry for a server, keyed by its bare command name. */
+export function manifestServer(serverName) {
+    return loadManifest().servers[path.basename(serverName)] ?? null;
+}
+/** Every auto-downloadable server in the manifest (for `lsp-server list`). */
+export function listManifestServers() {
+    return Object.entries(loadManifest().servers).map(([name, server]) => ({
+        name,
+        languageId: server.languageId,
+        releaseTag: server.releaseTag,
+    }));
+}
+/** Whether the manifest can, in principle, auto-provide this server. */
+export function isAutoDownloadable(serverName) {
+    return manifestServer(serverName) != null;
+}
+/**
+ * Root of the managed server cache. Defaults to `~/.octocode/lsp` (consistent
+ * with the rest of octocode's home), overridable via `OCTOCODE_LSP_CACHE_DIR`
+ * for read-only/ephemeral sandbox HOMEs or to point at a pre-baked image path.
+ */
+export function managedCacheRoot(env = process.env) {
+    const override = env.OCTOCODE_LSP_CACHE_DIR?.trim();
+    if (override)
+        return path.resolve(override);
+    return path.join(homedir(), '.octocode', 'lsp');
+}
+/** Where a provisioned binary lives once installed/extracted. */
+export function cachedServerBinPath(serverName, platformId = detectPlatformId()) {
+    const server = manifestServer(serverName);
+    const asset = server?.platforms[platformId];
+    if (!server || !asset)
+        return null;
+    return path.join(managedCacheRoot(), path.basename(serverName), server.releaseTag, asset.binName);
+}
+/**
+ * If a managed binary is already present AND verified in the cache (downloaded
+ * by a prior run, by CI, or pre-baked), return its absolute path. A binary is
+ * only trusted when its sibling `<binName>.ok` completion marker exists — a
+ * half-written binary from an interrupted install has no marker and is ignored,
+ * so it never resolves as "installed". Read-only — always safe to call.
+ */
+export function resolveCachedServer(serverName, platformId = detectPlatformId()) {
+    const binPath = cachedServerBinPath(serverName, platformId);
+    if (!binPath)
+        return null;
+    return existsSync(binPath) && existsSync(`${binPath}.ok`) ? binPath : null;
+}
+/** Human-readable provisioning guidance for a server with no resolved binary. */
+export function manifestInstallHint(serverName) {
+    const server = manifestServer(serverName);
+    if (!server)
+        return null;
+    const platformId = detectPlatformId();
+    const unsupported = server.unsupportedPlatforms?.[platformId];
+    if (unsupported)
+        return unsupported;
+    const mode = provisionMode();
+    if (mode === 'off') {
+        return `${serverName} can be auto-downloaded from ${server.repo} (${server.releaseTag}). Re-enable with OCTOCODE_LSP_AUTO_INSTALL=prompt (or =auto), or run \`lsp-server install ${serverName}\`.`;
+    }
+    return `${serverName} (${server.releaseTag}) will be auto-downloaded on first use from ${server.repo}.`;
+}

package/dist/lsp/serverManifestData.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestFile } from './serverManifest.js';
+export declare const MANIFEST: ManifestFile;

package/dist/lsp/serverManifestData.js

@@ -0,0 +1,33 @@
+export const MANIFEST = {
+    "$comment": "Auto-download manifest for portable, toolchain-free language servers. Verified 2026-06-28 against live GitHub Releases. SHA-256 pinned per asset — download is refused if the checksum mismatches. Scope: Rust (rust-analyzer, gz, auto-download ready), C/C++ (clangd, zip, auto-download ready). Toolchain-coupled servers (gopls/go, jdtls/jre) are detect-and-instruct; pure-JS servers (typescript-language-server, pyright, yaml/json/html/css) are bundled npm deps. Markdown/MDX handled by the MINIFIER, NOT LSP.",
+    "version": 1,
+    "servers": {
+        "rust-analyzer": {
+            "languageId": "rust",
+            "repo": "rust-lang/rust-analyzer",
+            "releaseTag": "2026-06-22",
+            "platforms": {
+                "darwin-arm64": { "url": "https://github.com/rust-lang/rust-analyzer/releases/download/2026-06-22/rust-analyzer-aarch64-apple-darwin.gz", "archive": "gz", "binName": "rust-analyzer", "sha256": "c8cdf6d5e488752b907d5ee15e31768b59a78d992e9a54b9f9660e1bfdf39f27" },
+                "darwin-x64": { "url": "https://github.com/rust-lang/rust-analyzer/releases/download/2026-06-22/rust-analyzer-x86_64-apple-darwin.gz", "archive": "gz", "binName": "rust-analyzer", "sha256": "feb7c170d2c1a2e4b8a88ac73f937eddb576828e3821b0a63ee0e64bd0bc9440" },
+                "linux-x64": { "url": "https://github.com/rust-lang/rust-analyzer/releases/download/2026-06-22/rust-analyzer-x86_64-unknown-linux-gnu.gz", "archive": "gz", "binName": "rust-analyzer", "sha256": "9602ca5b24dcaa07a5a021274763bed367d8a32da9a226fe3e139de3306569cb" },
+                "linux-x64-musl": { "url": "https://github.com/rust-lang/rust-analyzer/releases/download/2026-06-22/rust-analyzer-x86_64-unknown-linux-musl.gz", "archive": "gz", "binName": "rust-analyzer", "sha256": "fe1d7b0e9733f7a439e4b6f27b8c4cc7afd87ae28fc5b496eb8df31d674b78dd" },
+                "linux-arm64": { "url": "https://github.com/rust-lang/rust-analyzer/releases/download/2026-06-22/rust-analyzer-aarch64-unknown-linux-gnu.gz", "archive": "gz", "binName": "rust-analyzer", "sha256": "bf65b0d4586f127ab11bf33476dd6aac82dad173946c5d3b1cede19d63ae85ed" },
+                "win32-x64": { "url": "https://github.com/rust-lang/rust-analyzer/releases/download/2026-06-22/rust-analyzer-x86_64-pc-windows-msvc.zip", "archive": "zip", "binPath": "rust-analyzer.exe", "binName": "rust-analyzer.exe", "sha256": "6071dc5b28aa6d22c715f63c08d75b827c066be4ea866796587e52ed48b2922f" },
+                "win32-arm64": { "url": "https://github.com/rust-lang/rust-analyzer/releases/download/2026-06-22/rust-analyzer-aarch64-pc-windows-msvc.zip", "archive": "zip", "binPath": "rust-analyzer.exe", "binName": "rust-analyzer.exe", "sha256": "30f873713ea3663db10999c23e95b74fe19968c893d5c0e9b8a896b31dbf8cf8" }
+            }
+        },
+        "clangd": {
+            "languageId": "cpp",
+            "repo": "clangd/clangd",
+            "releaseTag": "22.1.0",
+            "launchArgs": [],
+            "platforms": {
+                "darwin-arm64": { "url": "https://github.com/clangd/clangd/releases/download/22.1.0/clangd-mac-22.1.0.zip", "archive": "zip", "binPath": "clangd_22.1.0/bin/clangd", "binName": "clangd", "sha256": "e31e271fe11f6dcd7cf87ca74be4a12788ff8ce5a0b07762583e335c058e939a" },
+                "darwin-x64": { "url": "https://github.com/clangd/clangd/releases/download/22.1.0/clangd-mac-22.1.0.zip", "archive": "zip", "binPath": "clangd_22.1.0/bin/clangd", "binName": "clangd", "sha256": "e31e271fe11f6dcd7cf87ca74be4a12788ff8ce5a0b07762583e335c058e939a" },
+                "linux-x64": { "url": "https://github.com/clangd/clangd/releases/download/22.1.0/clangd-linux-22.1.0.zip", "archive": "zip", "binPath": "clangd_22.1.0/bin/clangd", "binName": "clangd", "sha256": "71eddc5303da9a5bc5e8b509488b5b2c5acf45f20e33b8394e71a12a56d67198" },
+                "win32-x64": { "url": "https://github.com/clangd/clangd/releases/download/22.1.0/clangd-windows-22.1.0.zip", "archive": "zip", "binPath": "clangd_22.1.0/bin/clangd.exe", "binName": "clangd.exe", "sha256": "c54e57dbff3ccc9e8352367ddb7030ad3f624073ec58c7477424e7919f578572" }
+            },
+            "unsupportedPlatforms": { "linux-arm64": "clangd publishes no linux-arm64 release asset; install via the system package manager." }
+        }
+    }
+};

package/dist/lsp/serverProvisioner.d.ts

@@ -0,0 +1,19 @@
+import { type PlatformId } from './platform.js';
+import { provisionMode } from './serverManifest.js';
+export interface ProvisionResult {
+    ok: boolean;
+    path?: string;
+    source?: 'already-present' | 'downloaded';
+    error?: string;
+}
+/**
+ * Provision `serverName` into the managed cache. Idempotent: returns the
+ * already-present path when a verified copy exists. Pure-data inputs come from
+ * `serverManifest.json`; nothing is executed during install.
+ */
+export declare function provisionServer(serverName: string, options?: {
+    mode?: ReturnType<typeof provisionMode>;
+    signal?: AbortSignal;
+}): Promise<ProvisionResult>;
+/** Remove a server from the managed cache only (never touches external installs). */
+export declare function uninstallServer(serverName: string, platformId?: PlatformId): boolean;