@herbertgao/pi-extensions 2026.9.0 → 2026.9.2

package/node_modules/pi-lens/dist/clients/installer/index.js

@@ -29,16 +29,17 @@
  * - rust-analyzer (Rust LSP) [GitHub release]
  * - golangci-lint (Go linting) [GitHub release]
  *
- * Manual install required (25+ tools):
- * - yaml-language-server: npm install -g yaml-language-server
- * - vscode-json-languageserver: npm install -g vscode-langservers-extracted
- * - bash-language-server: npm install -g bash-language-server
- * - svelte-language-server: npm install -g svelte-language-server
- * - vscode-css-languageserver: npm install -g vscode-langservers-extracted
- * - @prisma/language-server: npm install -g @prisma/language-server
- * - dockerfile-language-server: npm install -g dockerfile-language-server-nodejs
- * - @vue/language-server: npm install -g @vue/language-server
- * - And all language-specific servers (gopls, rust-analyzer, etc.)
+ * Every other managed tool (including several the list above omits, e.g.
+ * bash-language-server, yaml-language-server, svelte-language-server,
+ * @prisma/language-server, @vue/language-server, dockerfile-language-server-nodejs,
+ * and vscode-css-languageserver — all of which ARE auto-installed) is
+ * documented by the `TOOLS` array below, not restated here. #2638: a
+ * hand-kept "manual install" list naming specific package specs used to live
+ * in this comment, drifted from `TOOLS` (it named a since-unpublished npm
+ * package for the CSS entry, and several tools it called "manual" were
+ * already auto-install above) and nothing caught it. `TOOLS` is the single
+ * source of truth for every id, package, and strategy; deleted rather than
+ * re-derived, since a comment cannot be generated from code at write time.
  *
  * Strategies:
  * - npm packages via npx/bun
@@ -234,7 +235,12 @@ export const TOOLS = [
         checkCommand: "typescript-language-server",
         checkArgs: ["--version"],
         installStrategy: "npm",
-        packageName: "typescript-language-server",
+        // Pinned below the package's own floor: 6.0.0 declares
+        // engines.node >=22.22.2, above the pi host's own floor (pi-lens
+        // must never require more than pi does — #2633) — an unpinned
+        // install here resolves latest and prints EBADENGINE on any pi
+        // host's supported Node. 5.3.0's own floor is engines.node >=20.
+        packageName: "typescript-language-server@5.3.0",
         binaryName: "typescript-language-server",
     },
     {
@@ -440,7 +446,7 @@ export const TOOLS = [
         checkCommand: "vscode-html-language-server",
         checkArgs: ["--version"],
         installStrategy: "npm",
-        packageName: "vscode-html-languageserver-bin",
+        packageName: "vscode-langservers-extracted",
         binaryName: "vscode-html-language-server",
     },
     {
@@ -529,7 +535,7 @@ export const TOOLS = [
         checkCommand: "vscode-css-language-server",
         checkArgs: ["--version"],
         installStrategy: "npm",
-        packageName: "vscode-css-languageserver",
+        packageName: "vscode-langservers-extracted",
         binaryName: "vscode-css-language-server",
     },
     {
@@ -542,10 +548,27 @@ export const TOOLS = [
         binaryName: "docker-langserver",
     },
     {
+        // #2722: intelephense has no CLI — its entry calls createConnection()
+        // unconditionally — and Node prints the offending source line before the
+        // error. The bundle is one ~4 MB minified line, so the transport-required
+        // marker #208 rescues on lands at byte 4,154,741 of a 4,423,356-byte
+        // stderr while Node truncates piped stderr at 1 MiB on exit. Measured on
+        // intelephense@1.18.5, linux, Node v22.22.1:
+        //   $ intelephense --version 2>&1 | wc -c              -> 1048576
+        //   $ intelephense --version 2>&1 | grep -c "Connection input stream is not set" -> 0
+        //   $ intelephense --version 2>err.txt; wc -c < err.txt -> 4423356
+        // Same run over the alternatives, each with stdin closed the way
+        // verifyToolBinary closes it (`input: ""`):
+        //   --help, -v, --socket=0 -> identical dump (exit 1, 4423356 bytes,
+        //     marker at 4154741, 1048576 through a pipe, marker absent)
+        //   --stdio                -> exit 1 with ZERO bytes on either stream,
+        //     so it carries no marker to rescue on either.
+        // No checkArgs value produces a verdict. Verified spawn-free instead.
         id: "intelephense",
         name: "Intelephense",
         checkCommand: "intelephense",
         checkArgs: ["--version"],
+        verification: "package-entry",
         installStrategy: "npm",
         packageName: "intelephense",
         binaryName: "intelephense",
@@ -1823,7 +1846,7 @@ const lspTransportRequiredMatcher = /Connection (?:input|output) stream is not s
  * correctly reports "no pin" rather than mistaking the scope for a version.
  * Returns undefined when packageName has no explicit `@version` suffix.
  */
-function parsePinnedVersion(packageName) {
+export function parsePinnedVersion(packageName) {
     const at = packageName.lastIndexOf("@");
     if (at <= 0)
         return undefined;
@@ -1845,6 +1868,111 @@ function extractVersionToken(output) {
  * maven/archive) never populate or read this map.
  */
 const lastManagedInstallVersion = new Map();
+/**
+ * The package whose entry module verifies `tool`'s managed install spawn-free,
+ * or undefined when the tool is verified by spawning `checkArgs` (#2722).
+ * Registry-declared per tool — never inferred from the strategy: a spawn probe
+ * is the stronger check everywhere it can actually return a verdict.
+ */
+export function packageEntryVerification(tool) {
+    return tool.verification === "package-entry" ? tool.packageName : undefined;
+}
+/**
+ * Spawn-free verification of a managed npm install (#2722).
+ *
+ * For an stdio LSP server with no CLI surface, every `checkArgs` value is a
+ * throw, and #208's transport-required rescue is output-ORDER dependent: Node
+ * prints the offending source line ahead of the error, so a server whose bundle
+ * is megabytes of minified JS pushes the marker past both our retained window
+ * and Node's own 1 MiB pipe truncation. The bytes never leave the child, so no
+ * spawn can answer "is this install intact".
+ *
+ * The evidence used instead is the same class the `archive` strategy already
+ * accepts through `treeMarker`: the installed tree is inspected on disk. The
+ * install verifies when the package directory beside the `.bin` shim carries a
+ * readable `package.json` with a `version`, and the entry module that
+ * package.json itself names — `bin[<shim name>]` or a bare `bin` string —
+ * exists as a non-empty file. `main` is deliberately NOT a fallback: npm
+ * creates the `node_modules/.bin/<shim>` this function is given only from a
+ * `bin` field, so a manifest without one cannot be the manifest behind this
+ * shim. That is exactly what `verifyToolBinary` was documented to catch here —
+ * broken symlinks and partial installs — and it is strictly more than the
+ * `--version` spawn can report for this class.
+ */
+export async function verifyNpmPackageEntry(binPath, packageName) {
+    // `<...>/node_modules/.bin/<shim>` → `<...>/node_modules`.
+    const nodeModulesDir = path.dirname(path.dirname(binPath));
+    const pinned = parsePinnedVersion(packageName);
+    const bareName = pinned
+        ? packageName.slice(0, -(pinned.length + 1))
+        : packageName;
+    const packageDir = path.join(nodeModulesDir, ...bareName.split("/"));
+    const shimName = path
+        .basename(binPath)
+        .replace(/\.(cmd|exe|ps1|bat)$/i, "")
+        .toLowerCase();
+    const fail = (reason) => {
+        logSessionStart(`auto-install verify: failed for ${binPath} (check=package-entry, kind=${reason})`);
+        return false;
+    };
+    // R2-F1: the shim ITSELF, before anything else. Every path below is DERIVED
+    // from `binPath`, so without this a partial install — npm never wrote the
+    // `.bin` entry, or wrote one that is empty, a directory, or a symlink
+    // dangling at a deleted target — verified `true` on the strength of a
+    // package tree that nothing can execute, and `installNpmTool` then recorded
+    // the install as SUCCEEDED. `classifyInstallOutcome` grades any non-"failed"
+    // outcome as `⚠ unavailable (succeeded)`, so that answer re-hid exactly the
+    // nightly row #2722 exists to expose. `statSync` FOLLOWS the link, which is
+    // what makes missing and dangling one branch.
+    try {
+        const shim = statSync(binPath);
+        if (!shim.isFile() || shim.size === 0)
+            return fail("shim-not-a-file");
+    }
+    catch {
+        return fail("shim-missing");
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(await fs.readFile(path.join(packageDir, "package.json"), "utf8"));
+    }
+    catch {
+        return fail("package-json-unreadable");
+    }
+    if (typeof manifest.version !== "string" || !manifest.version) {
+        return fail("package-json-no-version");
+    }
+    const bin = manifest.bin;
+    const entry = typeof bin === "string"
+        ? bin
+        : bin && typeof bin === "object"
+            ? Object.entries(bin).find(
+            // Case-folded on purpose: on a case-insensitive filesystem the
+            // shim on disk can differ in case from the manifest key npm
+            // wrote it from, and `path.basename` reads the disk name.
+            ([name]) => name.toLowerCase() === shimName)?.[1]
+            : undefined;
+    if (typeof entry !== "string" || !entry) {
+        return fail("package-json-no-entry");
+    }
+    try {
+        const stat = statSync(path.join(packageDir, entry));
+        if (!stat.isFile() || stat.size === 0)
+            return fail("entry-not-a-file");
+    }
+    catch {
+        return fail("entry-missing");
+    }
+    // R2-F3 (catalog shape 31): "did the new verifier run at all, and on what"
+    // has to be answerable from sessionstart.log, not only from a debug build —
+    // the failure branches above already log there. Measured volume on a real
+    // intelephense install, scratch PI_LENS_HOME: TWO rows on the session that
+    // installs (installNpmTool's verify, then the post-install resolution), and
+    // ZERO on every later session — the probe cache answers before any verify
+    // runs (`auto-install ensure intelephense: probe cache hit`).
+    logSessionStart(`auto-install verify: succeeded for ${binPath} (check=package-entry, version=${manifest.version}, entry=${entry})`);
+    return true;
+}
 /**
  * Verify a tool binary actually works by running its configured checkArgs.
  * This catches broken symlinks, partial installs, and corrupted binaries.
@@ -1872,7 +2000,26 @@ onTransient,
  * sensitive caller on the dispatch hot path passes a shorter one and treats
  * the expiry as transient rather than as a verdict (#1657).
  */
-timeoutMs = 10000, verificationArgs = ["--version"]) {
+timeoutMs = 10000, verificationArgs = ["--version"], 
+/**
+ * Package name from {@link packageEntryVerification} — present only for a
+ * registry entry declaring `verification: "package-entry"`. When present the
+ * spawn is skipped entirely and {@link verifyNpmPackageEntry} answers (#2722).
+ */
+packageEntryOf, 
+/**
+ * Called when a `false` verdict is INCONCLUSIVE rather than a verdict: the
+ * transport-required matcher was armed, never matched, and the child's
+ * output was cut off before the tail arrived, so the #208 rescue could not
+ * be evaluated at all (#2722). Distinct from `onTransient` on purpose — the
+ * prober DID run to completion and re-probing reproduces it exactly, so this
+ * is a durable "cannot be verified", not a stall (catalog shape 13). A
+ * caller must not treat it as "broken" and delete the installation.
+ */
+onInconclusive) {
+    if (packageEntryOf !== undefined) {
+        return verifyNpmPackageEntry(binPath, packageEntryOf);
+    }
     // #2015: safeSpawnAsync instead of raw spawn. Raw spawn's timeout
     // SIGTERMed only cmd.exe on Windows (.cmd shims run shell:true), orphaning
     // the grandchild node process - which kept scanning, held handles against
@@ -1931,6 +2078,31 @@ timeoutMs = 10000, verificationArgs = ["--version"]) {
         // verdict from the binary (#1569 transient semantics).
         if (result.signal !== undefined || result.spawnFailure)
             onTransient?.();
+        if (result.outputTruncated &&
+            result.signal === undefined &&
+            !result.spawnFailure) {
+            // #2722: the transport-required matcher above is armed on EVERY probe,
+            // and it never matched — but the output we kept is a prefix, so the
+            // marker may simply sit past it (intelephense emits ~4 MB of bundle
+            // ahead of its own diagnostic). "Unmatched within a truncated prefix"
+            // is not "this binary is broken"; callers must not delete the install
+            // on it. Recorded as its own kind so a monitor can tell an unreadable
+            // probe apart from a rejected binary.
+            //
+            // R2-F4: gated on the probe having actually FINISHED. A verbose child
+            // that is SIGTERMed at the timeout also arrives here truncated, and
+            // that is the #1569 transient class one line above, not this one —
+            // ungated, the two overlapped and `installNpmTool` (which tests
+            // inconclusive first) replaced the #2015 transient message with this
+            // one. The doc comment's "the prober DID run to completion" is now
+            // true rather than aspirational.
+            onInconclusive?.();
+            recordDegradationOnce({
+                kind: "installer-verification-inconclusive",
+                subject: binPath,
+                reason: `transport-required marker unresolved in truncated output (${verificationArgs.join(" ")})`,
+            });
+        }
         const kind = result.spawnFailure?.kind ??
             (result.signal
                 ? `killed-signal=${result.signal}`
@@ -2050,7 +2222,7 @@ export async function getAllToolStatuses() {
         const localPath = installerPlatform() === "win32" ? `${localBase}.cmd` : localBase;
         try {
             await fs.access(localPath);
-            if (await verifyToolBinary(localPath, undefined, undefined, getToolVerificationTimeout(tool), tool.checkArgs)) {
+            if (await verifyToolBinary(localPath, undefined, undefined, getToolVerificationTimeout(tool), tool.checkArgs, packageEntryVerification(tool))) {
                 status.installed = true;
                 status.source = "pi-lens-auto";
                 status.path = localPath;
@@ -2219,7 +2391,7 @@ async function getToolPathResolved(toolId, onTransient) {
         const cmdPath = `${localBase}.cmd`;
         try {
             await fs.access(cmdPath);
-            if (await verifyToolBinary(cmdPath, recordVersion, onTransient, getToolVerificationTimeout(tool), tool.checkArgs)) {
+            if (await verifyToolBinary(cmdPath, recordVersion, onTransient, getToolVerificationTimeout(tool), tool.checkArgs, packageEntryVerification(tool))) {
                 return cmdPath;
             }
             logSessionStart(`auto-install verify: ${cmdPath} exists but is broken, will reinstall`);
@@ -2232,7 +2404,7 @@ async function getToolPathResolved(toolId, onTransient) {
         const exePath = `${localBase}.exe`;
         try {
             await fs.access(exePath);
-            if (await verifyToolBinary(exePath, recordVersion, onTransient, getToolVerificationTimeout(tool), tool.checkArgs)) {
+            if (await verifyToolBinary(exePath, recordVersion, onTransient, getToolVerificationTimeout(tool), tool.checkArgs, packageEntryVerification(tool))) {
                 return exePath;
             }
             logSessionStart(`auto-install verify: ${exePath} exists but is broken, will reinstall`);
@@ -2244,7 +2416,7 @@ async function getToolPathResolved(toolId, onTransient) {
     if (installerPlatform() !== "win32") {
         try {
             await fs.access(localBase);
-            if (await verifyToolBinary(localBase, recordVersion, onTransient, getToolVerificationTimeout(tool), tool.checkArgs)) {
+            if (await verifyToolBinary(localBase, recordVersion, onTransient, getToolVerificationTimeout(tool), tool.checkArgs, packageEntryVerification(tool))) {
                 return localBase;
             }
             logSessionStart(`auto-install verify: ${localBase} exists but is broken, will reinstall`);
@@ -2867,6 +3039,7 @@ export function npmToolNeedsPostinstall(packageName) {
  * that wanders off it.
  */
 export function getRefreshableManagedNpmTools() {
+    const seenPackages = new Set();
     return getRefreshableManagedTools()
         .filter((candidate) => candidate.strategy === "npm")
         .map((candidate) => ({
@@ -2875,7 +3048,13 @@ export function getRefreshableManagedNpmTools() {
         // have both, so these are total.
         packageName: candidate.packageName,
         binaryName: candidate.binaryName,
-    }));
+    }))
+        .filter((candidate) => {
+        if (seenPackages.has(candidate.packageName))
+            return false;
+        seenPackages.add(candidate.packageName);
+        return true;
+    });
 }
 /** The Maven GAV a `maven` entry pins, as a stable identity string. */
 function mavenCoordinate(spec) {
@@ -2922,6 +3101,7 @@ export function getRefreshableManagedTools() {
                     packageName: tool.packageName,
                     binaryName: tool.binaryName,
                     verificationTimeoutMs: tool.verificationTimeoutMs,
+                    packageEntryOf: packageEntryVerification(tool),
                 });
                 break;
             }
@@ -3303,10 +3483,10 @@ async function refreshPackageManagerManagedTool(tool) {
     const installed = tool.installStrategy === "pip"
         ? // `-U` is the whole fix: without it pip treats the installed copy as
             // satisfying the requirement and the day-one version never moves.
-            await installPipTool(tool.packageName, { upgrade: true })
+            await installPipTool(tool.id, tool.packageName, { upgrade: true })
         : // `gem install` always fetches the newest version that satisfies the
             // requirement, so the install command IS the upgrade command.
-            await installGemTool(tool.packageName);
+            await installGemTool(tool.id, tool.packageName);
     if (!installed) {
         return {
             ok: false,
@@ -3734,7 +3914,26 @@ async function installArchiveTool(tool) {
         return undefined;
     }
 }
-async function installNpmTool(packageName, binaryName, verificationArgs = ["--version"], verificationTimeoutMs = 10_000) {
+/**
+ * Record a genuine package-manager install exception against `toolId` and
+ * log it — the one place `installNpmTool`/`installPipTool`/`installGemTool`'s
+ * catch blocks funnel through (#2661 review F3/Sonar: the three catches were
+ * byte-identical but for the strategy label, a duplication SonarCloud's new-
+ * code gate correctly flagged). The real error (registry E404, EBADENGINE, a
+ * network failure, "no version satisfies…") lands in `installFailureReasons`
+ * so a caller that distinguishes a genuine installer defect from a policy
+ * decline (the tool-smoke lane, #2638) sees the actual message, never the
+ * generic fallback `finishInstallAttempt` uses when nothing set it.
+ */
+function recordPackageManagerInstallException(toolId, strategyLabel, packageName, err) {
+    const message = err.message;
+    logSessionStart(`auto-install ${strategyLabel} ${packageName}: exception: ${message}`);
+    installFailureReasons.set(toolId, message);
+    return undefined;
+}
+async function installNpmTool(toolId, packageName, binaryName, verificationArgs = ["--version"], verificationTimeoutMs = 10_000, 
+/** See {@link packageEntryVerification} — spawn-free verification (#2722). */
+packageEntryOf) {
     try {
         // Ensure tools directory exists
         await fs.mkdir(TOOLS_DIR, { recursive: true });
@@ -3814,11 +4013,15 @@ async function installNpmTool(packageName, binaryName, verificationArgs = ["--ve
         debugLog(`Verifying ${binaryName}...`);
         let isValid = false;
         let lastAttemptTransient = false;
+        let lastAttemptInconclusive = false;
         for (let attempt = 1; attempt <= 3; attempt++) {
             lastAttemptTransient = false;
+            lastAttemptInconclusive = false;
             isValid = await verifyToolBinary(binPath, undefined, () => {
                 lastAttemptTransient = true;
-            }, verificationTimeoutMs, verificationArgs);
+            }, verificationTimeoutMs, verificationArgs, packageEntryOf, () => {
+                lastAttemptInconclusive = true;
+            });
             if (isValid)
                 break;
             if (attempt < 3) {
@@ -3826,6 +4029,37 @@ async function installNpmTool(packageName, binaryName, verificationArgs = ["--ve
                 await new Promise((r) => setTimeout(r, 1000 * attempt));
             }
         }
+        if (!isValid && lastAttemptInconclusive) {
+            // #2722: the probe ran to completion but could not decide — the #208
+            // transport-required matcher was armed, never matched, and the kept
+            // output is a truncated prefix, so the marker may sit past it (the
+            // class intelephense fell into: ~4 MB of bundle ahead of the marker,
+            // unreachable through any pipe). Same rule as the transient branch
+            // below (#2015): a non-verdict must not delete a freshly installed
+            // package. Deliberately NOT folded into `lastAttemptTransient` —
+            // re-probing reproduces this exactly, so it is durable, and a
+            // transient verdict would keep re-arming the reinstall path
+            // (catalog shape 13).
+            // R2-F2: a non-verdict is a reason to keep ONLY while the tree on disk
+            // still looks like a complete install. With intelephense verified
+            // spawn-free, no registry entry reaches this branch healthy (measured:
+            // no other npm-strategy LSP server emits more than 1,527 bytes), so
+            // its live population is BROKEN servers that spew past the retained
+            // window and die — and for those the delete was the only repair that
+            // existed. Measured on npm 9.2.0 against a real managed prefix: a
+            // package file corrupted IN PLACE is not repaired by re-installing
+            // (`up to date`, the zeroed file stays zeroed), while a package
+            // directory, a `.bin` shim or a nested dependency that is GONE is
+            // reinstalled. So the same on-disk evidence `verification:
+            // "package-entry"` uses decides keep-vs-delete here — strictly as a
+            // gate, never as a verdict: the install is still recorded as failed,
+            // so the tool still reads `✗` and nothing is re-hidden.
+            if (await verifyNpmPackageEntry(binPath, packageName)) {
+                logSessionStart(`auto-install ${packageName}: verification inconclusive (output truncated before the transport-required marker) but the installed tree is intact; keeping installation for re-probe`);
+                return undefined;
+            }
+            logSessionStart(`auto-install ${packageName}: verification inconclusive AND the installed tree is incomplete; cleaning up so the next install can repair it`);
+        }
         if (!isValid && lastAttemptTransient) {
             // #2015: a killed/spawn-failed prober is NOT a verdict about the
             // binary (#1569 semantics). Cold-start verifies on fresh installs
@@ -3858,14 +4092,26 @@ async function installNpmTool(packageName, binaryName, verificationArgs = ["--ve
         return binPath;
     }
     catch (err) {
-        logSessionStart(`auto-install npm ${packageName}: exception: ${err.message}`);
-        return undefined;
+        return recordPackageManagerInstallException(toolId, "npm", packageName, err);
     }
 }
+/**
+ * The pip command ladder `installPipTool` tries, per platform, in priority
+ * order — exported so a caller that needs to know "is ANY pip toolchain
+ * reachable on this runner" (without running an install) probes the SAME
+ * candidates rather than a second, narrower guess (#2661 review F4/S5: the
+ * tool-smoke lane's own presence check tried bare `pip` only and missed a
+ * `pip3`-only or python-module-only runner).
+ */
+export function pipCommandCandidates() {
+    return process.platform === "win32"
+        ? ["pip", "py", "python"]
+        : ["pip3", "pip", "python3", "python"];
+}
 /**
  * Install a pip package tool
  */
-async function installPipTool(packageName, 
+async function installPipTool(toolId, packageName, 
 /**
  * Add `-U`, turning the install into an upgrade. Without it `pip install`
  * treats an already-present package as satisfied and leaves the day-one
@@ -3880,30 +4126,16 @@ options = {}) {
         const verb = options.upgrade
             ? ["install", "-U", "--user"]
             : ["install", "--user"];
-        const pipCandidates = isWindows
-            ? [
-                { command: "pip", args: [...verb, packageName] },
-                {
-                    command: "py",
-                    args: ["-m", "pip", ...verb, packageName],
-                },
-                {
-                    command: "python",
-                    args: ["-m", "pip", ...verb, packageName],
-                },
-            ]
-            : [
-                { command: "pip3", args: [...verb, packageName] },
-                { command: "pip", args: [...verb, packageName] },
-                {
-                    command: "python3",
-                    args: ["-m", "pip", ...verb, packageName],
-                },
-                {
-                    command: "python",
-                    args: ["-m", "pip", ...verb, packageName],
-                },
-            ];
+        // Built from `pipCommandCandidates()` — the single source of truth this
+        // module and any other caller (the tool-smoke lane's toolchain-presence
+        // probe, #2661 review) share, rather than a second, independently
+        // maintained ladder that can drift.
+        const pipCandidates = pipCommandCandidates().map((command) => ({
+            command,
+            args: command === "pip" || command === "pip3"
+                ? [...verb, packageName]
+                : ["-m", "pip", ...verb, packageName],
+        }));
         let lastError = "";
         for (const candidate of pipCandidates) {
             const pipResult = await safeSpawnAsync(candidate.command, candidate.args, {
@@ -4000,11 +4232,10 @@ options = {}) {
         throw new Error(`Failed to install ${packageName}: no usable pip command found (${lastError || "unknown error"})`);
     }
     catch (err) {
-        logSessionStart(`auto-install pip ${packageName}: exception: ${err.message}`);
-        return undefined;
+        return recordPackageManagerInstallException(toolId, "pip", packageName, err);
     }
 }
-async function installGemTool(packageName) {
+async function installGemTool(toolId, packageName) {
     try {
         const gemResult = await safeSpawnAsync("gem", ["install", packageName, "--no-document"], {
             timeout: 120_000,
@@ -4021,8 +4252,7 @@ async function installGemTool(packageName) {
         return packageName;
     }
     catch (err) {
-        logSessionStart(`auto-install gem ${packageName}: exception: ${err.message}`);
-        return undefined;
+        return recordPackageManagerInstallException(toolId, "gem", packageName, err);
     }
 }
 /**
@@ -4113,7 +4343,7 @@ export async function installTool(toolId) {
             case "npm": {
                 if (!tool.packageName || !tool.binaryName)
                     return false;
-                const npmPath = await installNpmTool(tool.packageName, tool.binaryName, tool.checkArgs, getToolVerificationTimeout(tool));
+                const npmPath = await installNpmTool(tool.id, tool.packageName, tool.binaryName, tool.checkArgs, getToolVerificationTimeout(tool), packageEntryVerification(tool));
                 if (npmPath !== undefined) {
                     // #1746 review F4: an install just resolved this package's range
                     // against the registry, so record it as freshly checked. Otherwise a
@@ -4139,13 +4369,13 @@ export async function installTool(toolId) {
             case "pip": {
                 if (!tool.packageName)
                     return false;
-                const pipPath = await installPipTool(tool.packageName);
+                const pipPath = await installPipTool(tool.id, tool.packageName);
                 return finishInstallAttempt(tool.id, pipPath !== undefined, startedAt);
             }
             case "gem": {
                 if (!tool.packageName)
                     return false;
-                const gemPath = await installGemTool(tool.packageName);
+                const gemPath = await installGemTool(tool.id, tool.packageName);
                 return finishInstallAttempt(tool.id, gemPath !== undefined, startedAt);
             }
             case "github": {