@cortexkit/aft-pi 0.16.1 → 0.17.0

package/dist/lsp-auto-install.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Orchestrates AFT's npm-based LSP auto-install.
+ *
+ * Flow at plugin startup:
+ *
+ *   1. Resolve already-cached LSP binary directories. Pass these to Rust as
+ *      `lsp_paths_extra` so the layered resolver finds them before PATH.
+ *
+ *   2. For each Pattern B/D server whose project is "relevant" (root marker
+ *      OR matching extension exists in the bounded project walk) AND not yet cached
+ *      AND not in `lsp.disabled`:
+ *
+ *        a. If a user pinned a version via `lsp.versions: {"<pkg>": "X"}`,
+ *           use that version directly (skip 7-day grace).
+ *        b. Else if cache says we checked recently (< grace_days ago) and
+ *           we have a known eligible version, use it.
+ *        c. Else probe the npm registry, apply 7-day grace filter.
+ *        d. If grace blocks all candidates AND the package is already
+ *           installed, log a warning and keep the existing version.
+ *           Otherwise skip + warn.
+ *
+ *   3. Spawn `bun add <pkg>@<version> --cwd <cache_dir> --ignore-scripts`
+ *      in the background. Drop a lockfile while running. Log progress.
+ *
+ *   4. The newly-installed binary will be picked up on the user's NEXT
+ *      plugin session — first session with auto-install just kicks off
+ *      the install. This matches OpenCode's "may need restart" UX and
+ *      avoids mid-session bridge restarts.
+ */
+/** Per-call configuration drawn from `lsp.*` plugin config. */
+export interface AutoInstallConfig {
+    /** Master enable. Default: true. */
+    autoInstall: boolean;
+    /** Supply-chain grace window. Default: 7. */
+    graceDays: number;
+    /** User-pinned versions (bypasses grace). E.g. `{ "pyright": "1.1.300" }`. */
+    versions: Readonly<Record<string, string>>;
+    /** Server IDs the user explicitly disabled. Lowercase string match against `NpmServerSpec.id`. */
+    disabled: ReadonlySet<string>;
+}
+/** Result returned to the caller. */
+export interface AutoInstallResult {
+    /** Bin directories of every cached install — pass to Rust as `lsp_paths_extra`. */
+    cachedBinDirs: string[];
+    /** Number of background installs kicked off. */
+    installsStarted: number;
+    /**
+     * Servers that were disabled or skipped at decision time (synchronous).
+     *
+     * Note: this only includes synchronous reasons (disabled, irrelevant,
+     * `auto_install: false`). Async reasons (grace blocked, registry probe
+     * failed, install crashed) populate via the `installsComplete` callback
+     * because they're known only after the background work runs.
+     */
+    skipped: Array<{
+        id: string;
+        reason: string;
+    }>;
+    /**
+     * Promise that resolves when EVERY backgrounded install settles. Each
+     * install holds its per-package install lock for the entire duration;
+     * concurrent sessions racing into the same package will see the lock
+     * held and back off honestly.
+     *
+     * Plugin startup ignores this; tests await it to assert install outcomes.
+     * Each completed install pushes its skip-reason into `skipped` (mutates
+     * the array shared with the synchronous return value).
+     */
+    installsComplete: Promise<void>;
+}
+export declare function abortInFlightAutoInstalls(): Promise<void>;
+/**
+ * Top-level entry point. Returns the list of bin directories that already
+ * have an installed binary AND kicks off background installs for missing
+ * packages relevant to this project.
+ *
+ * Caller passes `cachedBinDirs` to Rust as `lsp_paths_extra`. The result
+ * is correct on first launch even though some installs may still be
+ * running — those binaries appear in the cache on the NEXT session.
+ */
+export declare function runAutoInstall(projectRoot: string, config: AutoInstallConfig, fetchImpl?: typeof fetch): AutoInstallResult;
+//# sourceMappingURL=lsp-auto-install.d.ts.map

package/dist/lsp-auto-install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-auto-install.d.ts","sourceRoot":"","sources":["../src/lsp-auto-install.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAsBH,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,oCAAoC;IACpC,WAAW,EAAE,OAAO,CAAC;IACrB,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3C,kGAAkG;IAClG,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC/B;AAED,qCAAqC;AACrC,MAAM,WAAW,iBAAiB;IAChC,mFAAmF;IACnF,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,gDAAgD;IAChD,eAAe,EAAE,MAAM,CAAC;IACxB;;;;;;;OAOG;IACH,OAAO,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C;;;;;;;;;OASG;IACH,gBAAgB,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAkDD,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAM/D;AAiSD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,iBAAiB,EACzB,SAAS,GAAE,OAAO,KAAa,GAC9B,iBAAiB,CAqEnB"}

package/dist/lsp-cache.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Disk layout and bookkeeping for AFT's auto-installed LSP cache.
+ *
+ * Layout under `<aft-cache-root>/lsp-packages/`:
+ *
+ *   <pkg>/
+ *     node_modules/.bin/<binary>     ← actual installed binary
+ *     node_modules/<pkg>/...
+ *     package.json                   ← created by `bun add`
+ *     .aft-version-check             ← JSON: { last_checked: ISO, latest: "X.Y.Z" }
+ *     .aft-installing                ← presence = install in progress (lockfile)
+ *
+ * For scoped packages like `@vue/language-server`, the `@` is preserved in
+ * the directory path. `<pkg>` is URL-encoded to keep filesystem-safe paths
+ * for any future packages with unusual characters.
+ */
+/**
+ * Root directory that holds all AFT-installed LSP packages.
+ *
+ * Honors `AFT_CACHE_DIR` for tests so suites do not pollute the real
+ * user cache. Falls back to the platform cache root used by the CLI:
+ * `%LOCALAPPDATA%/aft` on Windows, `$XDG_CACHE_HOME/aft` or `~/.cache/aft`
+ * elsewhere.
+ */
+export declare function aftCacheBase(): string;
+export declare function lspCacheRoot(): string;
+/** Directory for one specific npm package's install. */
+export declare function lspPackageDir(npmPackage: string): string;
+/** Path to the binary inside that package's `node_modules/.bin/`. */
+export declare function lspBinaryPath(npmPackage: string, binary: string): string;
+/** Directory passed to Rust as part of `lsp_paths_extra`. */
+export declare function lspBinDir(npmPackage: string): string;
+/** True when the cached binary file exists. */
+export declare function isInstalled(npmPackage: string, binary: string): boolean;
+/**
+ * Per-install metadata recorded after a successful install.
+ *
+ * Audit v0.17 #4: lets the next session detect a `lsp.versions` pin change.
+ * Audit v0.17 #1: optional `sha256` enables TOFU verification on GitHub installs.
+ */
+export interface InstalledMeta {
+    version: string;
+    installedAt: string;
+    sha256?: string;
+}
+/** Write the installed-version record into `installDir`. Best-effort. */
+export declare function writeInstalledMetaIn(installDir: string, version: string, sha256?: string): void;
+/** Read the installed-version record from `installDir`, or null if missing/corrupt. */
+export declare function readInstalledMetaIn(installDir: string): InstalledMeta | null;
+/** npm install path: write installed metadata into the package cache dir.
+ *
+ * Audit-2 v0.17 #1: pass `sha256` of the installed binary so the next
+ * session can do TOFU verification on reinstalls of the same version.
+ */
+export declare function writeInstalledMeta(packageKey: string, version: string, sha256?: string): void;
+/** npm install path: read installed metadata from the package cache dir. */
+export declare function readInstalledMeta(packageKey: string): InstalledMeta | null;
+/**
+ * Acquire an install lock for `lockKey` using an atomic `O_EXCL` open.
+ *
+ * The previous implementation used `existsSync` + `writeFileSync({flag:"w"})`
+ * which is a textbook TOCTOU: two concurrent processes both pass the check,
+ * both call write (which truncates with flag "w"), and both think they own
+ * the lock. With `wx` the second process's open() fails atomically.
+ *
+ * Stale-lock recovery: if the lock file exists, we read it. If the recorded
+ * PID is no longer alive OR the file is older than `STALE_LOCK_MS`, we claim
+ * the lock by atomically replacing it (unlink + create with `wx`). If that
+ * race fails (someone else just claimed it), we return false honestly.
+ *
+ * The lock file content is `<pid>\n<iso-timestamp>\n` so other processes
+ * can detect dead owners.
+ */
+export declare function acquireInstallLock(lockKey: string): boolean;
+export declare function releaseInstallLock(lockKey: string): void;
+/**
+ * Run `task` while holding the install lock. The lock is released only
+ * when `task` settles (resolves or rejects), not when it starts.
+ *
+ * Returns the task's resolved value, or `null` if the lock could not be
+ * acquired (caller should treat as "another install in progress").
+ */
+export declare function withInstallLock<T>(lockKey: string, task: () => Promise<T>): Promise<T | null>;
+/** Last-checked metadata stored next to the install. */
+interface VersionCheckRecord {
+    /** ISO timestamp of the last `npm registry probe`. */
+    last_checked: string;
+    /** Version string that was eligible at last check (after grace filter). */
+    latest_eligible: string | null;
+}
+export declare function readVersionCheck(npmPackage: string): VersionCheckRecord | null;
+export declare function writeVersionCheck(npmPackage: string, latest: string | null): void;
+/** True if more than `graceDays` × 24h have elapsed since `last_checked`. */
+export declare function shouldRecheckVersion(record: VersionCheckRecord | null, weeklyCheckIntervalMs?: number): boolean;
+export {};
+//# sourceMappingURL=lsp-cache.d.ts.map

package/dist/lsp-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-cache.d.ts","sourceRoot":"","sources":["../src/lsp-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAgBH;;;;;;;GAOG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAYrC;AAED,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAExE;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,+CAA+C;AAC/C,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CASvE;AAOD;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAID,yEAAyE;AACzE,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAY/F;AAED,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAiB5E;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAE7F;AAED,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAE1E;AAeD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiE3D;AAmBD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CASxD;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,CAAC,EACrC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAOnB;AAED,wDAAwD;AACxD,UAAU,kBAAkB;IAC1B,sDAAsD;IACtD,YAAY,EAAE,MAAM,CAAC;IACrB,2EAA2E;IAC3E,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAID,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAe9E;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAQjF;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,kBAAkB,GAAG,IAAI,EACjC,qBAAqB,SAA0B,GAC9C,OAAO,CAKT"}

package/dist/lsp-github-install.d.ts

@@ -0,0 +1,90 @@
+/**
+ * GitHub-release auto-installer for LSP servers (Pattern C).
+ *
+ * Cache layout under `<aft-cache-root>/lsp-binaries/`:
+ *
+ *   <id>/
+ *     bin/<binary>                  ← extracted binary (or shim)
+ *     extracted/                    ← validated extraction (kept for upgrades)
+ *     .aft-version-check            ← JSON: { last_checked, latest_eligible }
+ *     .aft-installing               ← lockfile while a download/extract runs
+ *
+ * `bin/<binary>` is what we add to `lsp_paths_extra` so the Rust resolver
+ * can find it.
+ *
+ * Extraction containment (audit #3):
+ *   1. Download to `<id>/<asset-name>` with a hard size cap (audit #4).
+ *   2. Extract into a quarantine dir `<id>/.staging-<rand>/`.
+ *   3. Walk the staging tree and reject any entry that is a symlink, hardlink,
+ *      or whose canonical path escapes the staging root.
+ *   4. Only after validation: `renameSync(staging, extracted)` atomically
+ *      replaces any prior extraction.
+ *   5. Stage dir is always cleaned up — success or failure.
+ *
+ * GitHub pin resolution (audit #5):
+ *   When `lsp.versions: { "owner/repo": "X" }` is set, we use GitHub's
+ *   `/releases/tags/<tag>` endpoint directly (with `v`-prefix tolerance)
+ *   instead of relying on the broader `/releases?per_page=30` probe. The
+ *   probe is for "what is the latest eligible version" — not "is this
+ *   specific pinned tag valid".
+ */
+import { type Arch, detectHostPlatform, findGithubServerById, GITHUB_LSP_TABLE, type GithubServerSpec, type Platform } from "./lsp-github-table.js";
+/** Final binary path under our cache. */
+export declare function ghBinaryPath(spec: GithubServerSpec, platform: Platform): string;
+export declare function isGithubInstalled(spec: GithubServerSpec, platform: Platform): boolean;
+export interface GithubInstallConfig {
+    autoInstall: boolean;
+    graceDays: number;
+    /** Per-package version pin map; key is `owner/repo`. Bypasses grace. */
+    versions: Readonly<Record<string, string>>;
+    disabled: ReadonlySet<string>;
+}
+/**
+ * Recursively validate that every entry under `stagingRoot` is contained
+ * within it (audit #3: zip-slip + symlink containment).
+ *
+ * Rejects:
+ *   - Any symlink (regardless of where it points). Symlinks in LSP
+ *     installs are extremely rare and would be a red flag.
+ *   - Any hardlink that has multiple inodes pointing at the same file
+ *     OUTSIDE the staging root (we can't easily detect this for hardlinks
+ *     to other paths inside the same archive, but those aren't a containment
+ *     escape).
+ *   - Any entry whose `realpath()` resolves outside `stagingRoot`. This
+ *     catches what the platform extractor missed if it failed to defend
+ *     against `..` traversal.
+ *
+ * Throws on any violation. The caller cleans up the staging dir.
+ */
+export declare function validateExtraction(stagingRoot: string): void;
+export interface GithubAutoInstallResult {
+    cachedBinDirs: string[];
+    installsStarted: number;
+    skipped: Array<{
+        id: string;
+        reason: string;
+    }>;
+    /**
+     * Promise that resolves when every backgrounded GitHub install settles.
+     * Each install holds its per-package install lock for its full duration.
+     * Plugin startup ignores this; tests await it.
+     */
+    installsComplete: Promise<void>;
+}
+export declare function abortInFlightGithubInstalls(): Promise<void>;
+/**
+ * Run the GitHub-release auto-install pass for every Pattern C server.
+ *
+ * Sync return: per-server cached bin dirs + skipped reasons known at decision
+ * time. Backgrounded installs settle into `installsComplete` so plugin
+ * startup is not blocked on slow downloads.
+ */
+export declare function runGithubAutoInstall(relevantServers: ReadonlySet<string>, config: GithubInstallConfig, fetchImpl?: typeof fetch): GithubAutoInstallResult;
+/**
+ * Cheap project-relevance scan for GitHub-distributed servers. Root markers
+ * win immediately; otherwise use the bounded shared extension walk for
+ * monorepos with nested source files.
+ */
+export declare function discoverRelevantGithubServers(projectRoot: string): Set<string>;
+export { type Arch, detectHostPlatform, findGithubServerById, GITHUB_LSP_TABLE, type GithubServerSpec, type Platform, };
+//# sourceMappingURL=lsp-github-install.d.ts.map

package/dist/lsp-github-install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-github-install.d.ts","sourceRoot":"","sources":["../src/lsp-github-install.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAiCH,OAAO,EACL,KAAK,IAAI,EACT,kBAAkB,EAClB,oBAAoB,EACpB,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EACd,MAAM,uBAAuB,CAAC;AAqB/B,yCAAyC;AACzC,wBAAgB,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAG/E;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CASrF;AASD,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3C,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC/B;AAwUD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CA0E5D;AAmSD,MAAM,WAAW,uBAAuB;IACtC,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C;;;;OAIG;IACH,gBAAgB,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAsBD,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,IAAI,CAAC,CAMjE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,EACpC,MAAM,EAAE,mBAAmB,EAC3B,SAAS,GAAE,OAAO,KAAa,GAC9B,uBAAuB,CAiFzB;AAID;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAyC9E;AAID,OAAO,EACL,KAAK,IAAI,EACT,kBAAkB,EAClB,oBAAoB,EACpB,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,KAAK,QAAQ,GACd,CAAC"}

package/dist/lsp-github-probe.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Probes the GitHub releases API for a project's tagged releases and
+ * selects the newest tag whose asset publication satisfies AFT's
+ * supply-chain grace window.
+ *
+ * Same threat model as the npm registry probe — we want releases that
+ * have been observable for at least `graceDays` so the community has
+ * time to detect compromised tarballs and yank them.
+ *
+ * For repos that put release tags on a `published_at` field (almost
+ * all of them), we filter on that. Pre-releases are skipped by default.
+ */
+interface GithubRelease {
+    tag_name: string;
+    name?: string;
+    published_at?: string;
+    draft?: boolean;
+    prerelease?: boolean;
+    assets?: Array<{
+        name: string;
+        browser_download_url: string;
+        size?: number;
+    }>;
+}
+export interface GithubVersionPickResult {
+    /** Chosen release tag (e.g. "v21.1.0" or "21.1.0"), or null if none qualifies. */
+    tag: string | null;
+    /** Asset list of the chosen release — used to find the right archive. */
+    assets: Array<{
+        name: string;
+        url: string;
+        size?: number;
+    }>;
+    /** True when releases exist but none is older than `graceDays`. */
+    blockedByGrace: boolean;
+}
+/**
+ * Pick the newest non-draft non-prerelease release whose `published_at`
+ * is at least `graceDays` ago.
+ *
+ * The GitHub `/releases` endpoint returns up to 30 releases sorted newest
+ * first by default — pagination ignored because servers we care about
+ * cycle stable releases on the order of weeks/months.
+ */
+export declare function pickEligibleRelease(releases: readonly GithubRelease[], graceDays: number, now?: number): GithubVersionPickResult;
+/**
+ * Fetch the GitHub releases list for `owner/repo` and apply the grace filter.
+ *
+ * Returns `null` on HTTP/network failure — caller should keep using whatever's
+ * already cached.
+ */
+export declare function probeGithubReleases(githubRepo: string, graceDays: number, fetchImpl?: typeof fetch): Promise<GithubVersionPickResult | null>;
+/**
+ * Throw if `version` contains anything outside the safe allowlist.
+ */
+export declare function assertSafeVersion(version: string): void;
+/**
+ * Strip a leading `v` from a release tag to get a clean version for asset
+ * templates that don't include the `v` prefix.
+ *
+ * Asserts the tag is safe via {@link assertSafeVersion} so callers can
+ * pass it into paths and command arguments without additional validation.
+ */
+export declare function stripTagV(tag: string): string;
+export {};
+//# sourceMappingURL=lsp-github-probe.d.ts.map

package/dist/lsp-github-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-github-probe.d.ts","sourceRoot":"","sources":["../src/lsp-github-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,oBAAoB,EAAE,MAAM,CAAC;QAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,uBAAuB;IACtC,kFAAkF;IAClF,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,yEAAyE;IACzE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5D,mEAAmE;IACnE,cAAc,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,SAAS,aAAa,EAAE,EAClC,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,MAAmB,GACvB,uBAAuB,CA4BzB;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,GAAE,OAAO,KAAa,GAC9B,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAyBzC;AAiBD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAMvD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C"}

package/dist/lsp-github-table.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Per-server GitHub-release configuration for LSP servers AFT can
+ * auto-download.
+ *
+ * Each entry is a templated asset-name pattern keyed by `(platform, arch)`.
+ * The installer resolves the latest eligible release tag (with 7-day grace),
+ * matches the asset against `assetTemplate(platform, arch, version)`,
+ * downloads it, extracts to the cache, and exposes the binary.
+ *
+ * NOTE: terraform-ls uses HashiCorp's release API, not GitHub. It's a
+ * separate code path; not included in this table.
+ *
+ * NOTE: oxlint is bundled inside the project's `node_modules/@oxlint/*`
+ * package via the existing project-node_modules resolution. AFT does not
+ * download it independently. Excluded from this table.
+ *
+ * NOTE: kotlin-language-server is hosted on JetBrains CDN, not GitHub.
+ * Skipped from auto-download for v0.17.0 — users install via Homebrew /
+ * scoop / Snap / coursier.
+ */
+export type Platform = "darwin" | "linux" | "win32";
+export type Arch = "x64" | "arm64";
+/**
+ * Asset name template — receives platform/arch (already mapped to the
+ * project's naming convention) and the resolved version, returns the
+ * literal asset filename to look for in the release `assets[]`.
+ *
+ * Returns `null` when this platform/arch combo is unsupported.
+ */
+export type AssetTemplate = (platform: Platform, arch: Arch, version: string) => string | null;
+export type ArchiveType = "tar.gz" | "tar.xz" | "zip";
+export interface GithubServerSpec {
+    /** AFT server-kind id (matches `crates/aft/src/lsp/registry.rs::ServerKind::id_str`). */
+    readonly id: string;
+    /** GitHub `owner/repo`. */
+    readonly githubRepo: string;
+    /** Binary name placed under the cache `bin/` dir after extraction. */
+    readonly binary: string;
+    /** Returns the asset filename and archive type for the given platform/arch + version. */
+    readonly resolveAsset: (platform: Platform, arch: Arch, version: string) => {
+        name: string;
+        archive: ArchiveType;
+    } | null;
+    /**
+     * Path inside the extracted archive where the binary lives, relative to the
+     * extraction root. May contain `${version}` placeholder. The installer
+     * looks up this path and copies/symlinks it to `bin/<binary>`.
+     */
+    readonly binaryPathInArchive: (platform: Platform, arch: Arch, version: string) => string;
+}
+export declare const GITHUB_LSP_TABLE: readonly GithubServerSpec[];
+/** Find an entry by AFT server id. */
+export declare function findGithubServerById(id: string): GithubServerSpec | undefined;
+/**
+ * Map Node's `process.platform` and `process.arch` to our (Platform, Arch)
+ * pair, or null when the host isn't supported.
+ */
+export declare function detectHostPlatform(): {
+    platform: Platform;
+    arch: Arch;
+} | null;
+//# sourceMappingURL=lsp-github-table.d.ts.map

package/dist/lsp-github-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-github-table.d.ts","sourceRoot":"","sources":["../src/lsp-github-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AACpD,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,OAAO,CAAC;AAEnC;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;AAE/F,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEtD,MAAM,WAAW,gBAAgB;IAC/B,yFAAyF;IACzF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,yFAAyF;IACzF,QAAQ,CAAC,YAAY,EAAE,CACrB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,MAAM,KACZ;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI,CAAC;IACnD;;;;OAIG;IACH,QAAQ,CAAC,mBAAmB,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;CAC3F;AA4HD,eAAO,MAAM,gBAAgB,EAAE,SAAS,gBAAgB,EAMvD,CAAC;AAEF,sCAAsC;AACtC,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE7E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,GAAG,IAAI,CAQ9E"}

package/dist/lsp-npm-table.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Maps AFT LSP server kinds to their npm packages and the binary names
+ * exposed in `node_modules/.bin/` after install.
+ *
+ * Used by the auto-install flow to decide which packages to fetch and to
+ * compute the `lsp_paths_extra` directory list passed to the Rust binary.
+ *
+ * Coverage matches OpenCode's `lsp/server.ts` `Npm.which(...)` calls. Any
+ * server NOT in this table is either:
+ *   1. Pattern A (PATH-only, install via system package manager)
+ *   2. Pattern C (GitHub-release auto-download — see lsp-github-table.ts)
+ *   3. Special (eslint/prisma — uses project's own node_modules)
+ */
+export interface NpmServerSpec {
+    /** AFT server-kind id (matches `crates/aft/src/lsp/registry.rs::ServerKind::id_str`). */
+    readonly id: string;
+    /** npm package name. */
+    readonly npm: string;
+    /** Binary name installed under `node_modules/.bin/`. */
+    readonly binary: string;
+    /** File extensions (without dot) the LSP serves. Used for project-relevance discovery. */
+    readonly extensions: readonly string[];
+    /** Project-root marker files (presence triggers install). Optional. */
+    readonly rootMarkers?: readonly string[];
+}
+export declare const NPM_LSP_TABLE: readonly NpmServerSpec[];
+/** Find an entry by AFT server id. */
+export declare function findNpmServerById(id: string): NpmServerSpec | undefined;
+/** Find an entry by binary name. */
+export declare function findNpmServerByBinary(binary: string): NpmServerSpec | undefined;
+//# sourceMappingURL=lsp-npm-table.d.ts.map

package/dist/lsp-npm-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-npm-table.d.ts","sourceRoot":"","sources":["../src/lsp-npm-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,aAAa;IAC5B,yFAAyF;IACzF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,wBAAwB;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,0FAA0F;IAC1F,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,uEAAuE;IACvE,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,eAAO,MAAM,aAAa,EAAE,SAAS,aAAa,EAoEjD,CAAC;AAEF,sCAAsC;AACtC,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAEvE;AAED,oCAAoC;AACpC,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE/E"}

package/dist/lsp-project-relevance.d.ts

@@ -0,0 +1,11 @@
+export declare function hasRootMarker(projectRoot: string, rootMarkers?: readonly string[]): boolean;
+/**
+ * Bounded extension scan for project relevance decisions.
+ *
+ * Root-marker checks happen before callers use this helper. This walk only
+ * answers "does this project contain one of the extensions we know how to
+ * serve?" and deliberately skips common dependency/build/cache directories so
+ * vendored files do not trigger heavyweight LSP installs.
+ */
+export declare function relevantExtensionsInProject(projectRoot: string, extToServer: Readonly<Record<string, readonly string[]>>): Set<string>;
+//# sourceMappingURL=lsp-project-relevance.d.ts.map

package/dist/lsp-project-relevance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-project-relevance.d.ts","sourceRoot":"","sources":["../src/lsp-project-relevance.ts"],"names":[],"mappings":"AAiBA,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAM3F;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,GACvD,GAAG,CAAC,MAAM,CAAC,CAmCb"}

package/dist/lsp-registry-probe.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Probes the npm registry for a package's available versions and selects
+ * the newest one that satisfies AFT's supply-chain grace window.
+ *
+ * Threat model: defends against typosquat/compromise attacks where a
+ * malicious version is published, then yanked within hours when caught.
+ * By default, AFT only installs versions that have been on the registry
+ * for at least 7 days, giving the community time to detect and respond.
+ *
+ * Grace days are configurable via `lsp.grace_days` (default 7). User
+ * pins via `lsp.versions: { "package": "X.Y.Z" }` bypass the filter.
+ */
+/** Per-version publish times indexed by version string. */
+type VersionTimes = Record<string, string>;
+interface RegistryResponse {
+    /** Map: version → ISO publish time. Also contains "created" / "modified". */
+    time?: VersionTimes;
+    /** dist-tags such as "latest", "next". */
+    "dist-tags"?: {
+        latest?: string;
+    };
+}
+export interface VersionPickResult {
+    /** The chosen version, or null if none qualifies. */
+    version: string | null;
+    /** True when the registry has versions but none is older than `graceDays`. */
+    blockedByGrace: boolean;
+    /** All eligible versions sorted by publish date (newest first). For tests/logs. */
+    eligible: ReadonlyArray<{
+        version: string;
+        publishedAt: string;
+    }>;
+}
+/**
+ * Pick a version from the registry response that:
+ *   1. is published at least `graceDays` ago
+ *   2. is the newest such version (per ISO publish time)
+ *
+ * Pre-release versions (semver "-" tags) are skipped.
+ */
+export declare function pickEligibleVersion(response: RegistryResponse, graceDays: number, now?: number): VersionPickResult;
+/**
+ * Fetch the registry document for `npmPackage` and apply the grace filter.
+ *
+ * Returns `null` on HTTP/network failure (logs a warning) so callers can
+ * fall back to "use whatever's currently installed".
+ */
+export declare function probeRegistry(npmPackage: string, graceDays: number, fetchImpl?: typeof fetch): Promise<VersionPickResult | null>;
+export {};
+//# sourceMappingURL=lsp-registry-probe.d.ts.map

package/dist/lsp-registry-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lsp-registry-probe.d.ts","sourceRoot":"","sources":["../src/lsp-registry-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,2DAA2D;AAC3D,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE3C,UAAU,gBAAgB;IACxB,6EAA6E;IAC7E,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,0CAA0C;IAC1C,WAAW,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACnC;AAED,MAAM,WAAW,iBAAiB;IAChC,qDAAqD;IACrD,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,8EAA8E;IAC9E,cAAc,EAAE,OAAO,CAAC;IACxB,mFAAmF;IACnF,QAAQ,EAAE,aAAa,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACnE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,MAAmB,GACvB,iBAAiB,CA0BnB;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,GAAE,OAAO,KAAa,GAC9B,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAoBnC"}

package/dist/onnx-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onnx-runtime.d.ts","sourceRoot":"","sources":["../src/onnx-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA0DH,4DAA4D;AAC5D,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,IAAI,MAAM,CAQ7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA4BlF;AA6LD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAU3D"}
+{"version":3,"file":"onnx-runtime.d.ts","sourceRoot":"","sources":["../src/onnx-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA0DH,4DAA4D;AAC5D,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,IAAI,MAAM,CAQ7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA4BlF;AAmKD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAU3D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/aft-pi",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "type": "module",
   "description": "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   "main": "dist/index.js",
@@ -26,11 +26,11 @@
     "zod": "^4.1.8"
   },
   "optionalDependencies": {
-    "@cortexkit/aft-darwin-arm64": "0.16.1",
-    "@cortexkit/aft-darwin-x64": "0.16.1",
-    "@cortexkit/aft-linux-arm64": "0.16.1",
-    "@cortexkit/aft-linux-x64": "0.16.1",
-    "@cortexkit/aft-win32-x64": "0.16.1"
+    "@cortexkit/aft-darwin-arm64": "0.17.0",
+    "@cortexkit/aft-darwin-x64": "0.17.0",
+    "@cortexkit/aft-linux-arm64": "0.17.0",
+    "@cortexkit/aft-linux-x64": "0.17.0",
+    "@cortexkit/aft-win32-x64": "0.17.0"
   },
   "devDependencies": {
     "@mariozechner/pi-coding-agent": "*",