@herbertgao/pi-extensions 2026.9.6 → 2026.9.8

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

@@ -61,9 +61,11 @@ import { assertInstallAllowed, projectTrustDenialReason, } from "../project-trus
 const _installerRequire = createRequire(import.meta.url);
 import { createGunzip } from "node:zlib";
 import { TRANSIENT_MAX_COOLDOWN_MS } from "../dispatch/runners/utils/availability-policy.js";
-import { recordDegradationOnce } from "../degradation-ledger.js";
+import { getDegradationLedgerGeneration, recordDegradationOnce, } from "../degradation-ledger.js";
 import { commitDurableStoreAsync } from "../durable-store.js";
 import { getGlobalPiLensDir } from "../file-utils.js";
+import { createGenerationMap } from "../generation-guard.js";
+import { resolveToolCwd } from "../tool-cwd.js";
 import { allAvailableGlobalBinDirs, installArgs, pmBinary, resolveNodePackageManager, } from "../package-manager.js";
 import { resetSafeSpawnWindowsCommandCache, safeSpawnAsync, } from "../safe-spawn.js";
 import { probeToolAsync } from "../tool-probe.js";
@@ -267,6 +269,27 @@ function managedGitHubFormatterTool(spec) {
     };
 }
 const MANAGED_GITHUB_FORMATTERS = [
+    {
+        id: "typstyle",
+        name: "typstyle",
+        owner: "typstyle-rs",
+        repo: "typstyle",
+        assetPattern: archAssetMatch({
+            linux: {
+                x64: "typstyle-x86_64-unknown-linux-gnu",
+                arm64: "typstyle-aarch64-unknown-linux-gnu",
+            },
+            darwin: {
+                x64: "typstyle-x86_64-apple-darwin",
+                arm64: "typstyle-aarch64-apple-darwin",
+            },
+            win32: {
+                x64: "typstyle-x86_64-pc-windows-msvc.exe",
+                arm64: "typstyle-aarch64-pc-windows-msvc.exe",
+            },
+        }),
+        kind: "binary",
+    },
     {
         id: "stylua",
         name: "StyLua",
@@ -1054,7 +1077,7 @@ export const TOOLS = [
                         : `${base}/lua-language-server-${version}-win32-x64.zip`;
                 return undefined;
             },
-            kind: "zip",
+            kind: (platform) => (platform === "win32" ? "zip" : "tgz"),
             stripComponents: 0,
             treeMarker: "bin",
         },
@@ -1432,6 +1455,34 @@ export const TOOLS = [
             binaryInArchive: "gleam",
         },
     },
+    {
+        // Tinymist publishes cargo-dist archives containing the `tinymist` binary
+        // for the supported desktop targets. The LSP server uses `tinymist lsp`.
+        id: "tinymist",
+        name: "Tinymist",
+        checkCommand: "tinymist",
+        checkArgs: ["--version"],
+        installStrategy: "github",
+        binaryName: "tinymist",
+        github: {
+            repo: "Myriad-Dreamin/tinymist",
+            assetMatch: archAssetMatch({
+                linux: {
+                    x64: "tinymist-x86_64-unknown-linux-gnu.tar.gz",
+                    arm64: "tinymist-aarch64-unknown-linux-gnu.tar.gz",
+                },
+                darwin: {
+                    x64: "tinymist-x86_64-apple-darwin.tar.gz",
+                    arm64: "tinymist-aarch64-apple-darwin.tar.gz",
+                },
+                win32: {
+                    x64: "tinymist-x86_64-pc-windows-msvc.zip",
+                    arm64: "tinymist-aarch64-pc-windows-msvc.zip",
+                },
+            }),
+            binaryInArchive: "tinymist",
+        },
+    },
     {
         // marksman ships a single BARE (uncompressed) binary per platform on GitHub
         // releases — no archive, so it lands via the bare-binary branch of
@@ -2678,12 +2729,14 @@ async function getNpmGlobalBinCandidates(onTransient) {
     return dirs;
 }
 async function findPipUserToolPath(binaryName, onTransient, verificationArgs = ["--version"], verificationTimeoutMs = 10_000) {
-    const isWindows = process.platform === "win32";
-    const userBaseCandidates = await getPythonUserBaseCandidates();
+    const isWindows = installerPlatform() === "win32";
+    const userBaseCandidates = [
+        path.join(getGlobalPiLensDir(), "pip-tools"),
+        path.join(getGlobalPiLensDir(), "pip-user"),
+        ...(await getPythonUserBaseCandidates()),
+    ];
     for (const userBase of userBaseCandidates) {
-        const scriptDirs = [
-            path.join(userBase, isWindows ? "Scripts" : "bin"),
-        ];
+        const scriptDirs = [pipScriptsDir(userBase, installerPlatform())];
         if (isWindows) {
             try {
                 const children = await fs.readdir(userBase, { withFileTypes: true });
@@ -3600,7 +3653,9 @@ 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.id, tool.packageName, { upgrade: true })
+            await installPipTool(tool.id, tool.packageName, tool.binaryName ?? tool.id, {
+                upgrade: true,
+            })
         : // `gem install` always fetches the newest version that satisfies the
             // requirement, so the install command IS the upgrade command.
             await installGemTool(tool.id, tool.packageName);
@@ -3798,9 +3853,35 @@ async function installMavenTool(tool) {
  * may return `undefined` (unsupported → caller degrades to "unavailable").
  * Exported for the tool-registry contract test.
  */
-export function resolveArchiveUrl(spec, platform = process.platform, arch = process.arch) {
+export function resolveArchiveUrl(spec, platform = installerPlatform(), arch = process.arch) {
     return typeof spec.url === "function" ? spec.url(platform, arch) : spec.url;
 }
+/** Resolve the archive format independently from the extractor implementation. */
+export function resolveArchiveKind(spec, platform = installerPlatform(), arch = process.arch) {
+    return typeof spec.kind === "function"
+        ? spec.kind(platform, arch)
+        : spec.kind;
+}
+function recordArchiveExtractionDegradation(toolId, format, reason) {
+    recordDegradationOnce({
+        kind: "managed-tool-install",
+        subject: `${toolId}:${format}`,
+        reason: `archive extraction ${reason}`,
+    });
+}
+async function stripExtractedArchiveRoot(dir, components) {
+    for (let i = 0; i < components; i++) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        const [entry] = entries;
+        if (entries.length !== 1 || !entry?.isDirectory())
+            return false;
+        const root = path.join(dir, entry.name);
+        for (const child of await fs.readdir(root))
+            await fs.rename(path.join(root, child), path.join(dir, child));
+        await fs.rm(root, { recursive: true, force: true });
+    }
+    return true;
+}
 /**
  * Move a verified-good extracted tree into its final, stable location without
  * ever leaving `finalDir` empty or missing while a working copy was there
@@ -3876,8 +3957,10 @@ async function installArchiveTool(tool) {
     if (!spec)
         return undefined;
     const binaryName = tool.binaryName ?? tool.id;
-    const isWindows = process.platform === "win32";
-    const url = resolveArchiveUrl(spec);
+    const platform = installerPlatform();
+    const isWindows = platform === "win32";
+    const archiveKind = resolveArchiveKind(spec, platform, process.arch);
+    const url = resolveArchiveUrl(spec, platform, process.arch);
     if (!url) {
         logSessionStart(`archive-install ${tool.id}: no archive for ${process.platform}/${process.arch} — unsupported, skipping`);
         return undefined;
@@ -3907,7 +3990,7 @@ async function installArchiveTool(tool) {
     // installed copy is now untouched until the replacement is proven good.
     const extractName = tool.id;
     const tmpExtractName = `${extractName}.refresh-tmp`;
-    const archiveName = `${tool.id}.download.${spec.kind === "zip" ? "zip" : "tgz"}`;
+    const archiveName = `${tool.id}.download.${archiveKind === "zip" ? "zip" : "tgz"}`;
     const extractDir = path.join(TOOLS_DIR, extractName);
     const tmpExtractDir = path.join(TOOLS_DIR, tmpExtractName);
     const tmpArchive = path.join(TOOLS_DIR, archiveName);
@@ -3925,34 +4008,62 @@ async function installArchiveTool(tool) {
         // dir — stripping would flatten/merge its sibling module folders — so the
         // flag is omitted. bsdtar handles both .tgz and .zip with -xf.
         const stripComponents = spec.stripComponents ?? 1;
-        const tarArgs = [
-            spec.kind === "tgz" ? "-xzf" : "-xf",
-            archiveName,
-            "-C",
-            tmpExtractName,
-            ...(stripComponents > 0 ? [`--strip-components=${stripComponents}`] : []),
-        ];
+        const extractionArgs = archiveKind === "zip" && isWindows
+            ? [
+                "-NoProfile",
+                "-Command",
+                `Expand-Archive -LiteralPath '${archiveName}' -DestinationPath '${tmpExtractName}' -Force`,
+            ]
+            : archiveKind === "zip"
+                ? ["-q", "-o", archiveName, "-d", tmpExtractName]
+                : [
+                    "-xzf",
+                    archiveName,
+                    "-C",
+                    tmpExtractName,
+                    ...(stripComponents > 0
+                        ? [`--strip-components=${stripComponents}`]
+                        : []),
+                ];
         // Resolve `tar` to an absolute path on Windows (System32\tar.exe is the
         // bsdtar shipped with Windows 10+) so extraction can't be hijacked via a
         // writable PATH entry — same hardening as the taskkill spawn. On POSIX `tar`
         // is a trusted coreutil whose absolute path varies by distro, so it stays
         // bare (consistent with every other tool spawn).
-        const tarBin = isWindows
-            ? `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\tar.exe`
-            : "tar";
-        const extractResult = await safeSpawnAsync(tarBin, tarArgs, {
+        const extractor = archiveKind === "zip" && isWindows
+            ? `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`
+            : archiveKind === "zip"
+                ? "unzip"
+                : isWindows
+                    ? `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\tar.exe`
+                    : "tar";
+        const extractionResult = await safeSpawnAsync(extractor, extractionArgs, {
             cwd: TOOLS_DIR,
             timeout: 120_000,
             ignoreAmbientSignal: true,
             lifetimeCoupled: true,
         });
         const extracted = {
-            ok: extractResult.status === 0,
-            stderr: extractResult.error?.message ?? extractResult.stderr,
+            ok: extractionResult.status === 0,
+            reason: extractionResult.spawnFailure?.kind === "tool-not-found"
+                ? "extractor-unavailable"
+                : extractionResult.spawnFailure
+                    ? "extractor-error"
+                    : "extractor-exit",
         };
         await fs.rm(tmpArchive, { force: true });
         if (!extracted.ok) {
-            logSessionStart(`archive-install ${tool.id}: extraction failed: ${extracted.stderr} — keeping installed version`);
+            recordArchiveExtractionDegradation(tool.id, archiveKind, extracted.reason);
+            logSessionStart(`archive-install ${tool.id}: ${archiveKind} extraction failed (${extracted.reason}) — keeping installed version`);
+            await fs
+                .rm(tmpExtractDir, { recursive: true, force: true })
+                .catch(() => { });
+            return undefined;
+        }
+        if (archiveKind === "zip" &&
+            !(await stripExtractedArchiveRoot(tmpExtractDir, stripComponents))) {
+            recordArchiveExtractionDegradation(tool.id, archiveKind, "layout-invalid");
+            logSessionStart(`archive-install ${tool.id}: ${archiveKind} layout invalid — keeping installed version`);
             await fs
                 .rm(tmpExtractDir, { recursive: true, force: true })
                 .catch(() => { });
@@ -3970,7 +4081,8 @@ async function installArchiveTool(tool) {
                 await fs.access(tmpMarker);
             }
             catch {
-                logSessionStart(`archive-install ${tool.id}: tree marker not found at ${tmpMarker} after extraction — keeping installed version`);
+                recordArchiveExtractionDegradation(tool.id, archiveKind, "marker-missing");
+                logSessionStart(`archive-install ${tool.id}: ${archiveKind} marker missing after extraction — keeping installed version`);
                 await fs
                     .rm(tmpExtractDir, { recursive: true, force: true })
                     .catch(() => { });
@@ -3992,7 +4104,8 @@ async function installArchiveTool(tool) {
             await fs.access(tmpResolvedInner);
         }
         catch {
-            logSessionStart(`archive-install ${tool.id}: launcher not found at ${tmpResolvedInner} after extraction — keeping installed version`);
+            recordArchiveExtractionDegradation(tool.id, archiveKind, "launcher-missing");
+            logSessionStart(`archive-install ${tool.id}: ${archiveKind} launcher missing after extraction — keeping installed version`);
             await fs
                 .rm(tmpExtractDir, { recursive: true, force: true })
                 .catch(() => { });
@@ -4231,24 +4344,25 @@ export function pipCommandCandidates() {
         ? ["pip", "py", "python"]
         : ["pip3", "pip", "python3", "python"];
 }
+/** Resolve the script directory used by a Python installation on each OS. */
+export function pipScriptsDir(base, platform = installerPlatform()) {
+    return path.join(base, platform === "win32" ? "Scripts" : "bin");
+}
+const pipPep668LoggedRefusals = createGenerationMap("installer-pep668-log");
 /**
  * Install a pip package tool
  */
-async function installPipTool(toolId, packageName, 
+async function installPipTool(toolId, packageName, binaryName, 
 /**
  * Add `-U`, turning the install into an upgrade. Without it `pip install`
  * treats an already-present package as satisfied and leaves the day-one
  * version in place forever — the freeze #1747 is about. The flag is the ONLY
- * difference between install and refresh: same command ladder, same
- * `--user` target, so a refresh can never write somewhere the install would
- * not have.
+ * difference between install and refresh within each selected environment.
  */
 options = {}) {
     try {
-        const isWindows = process.platform === "win32";
-        const verb = options.upgrade
-            ? ["install", "-U", "--user"]
-            : ["install", "--user"];
+        const isWindows = installerPlatform() === "win32";
+        const verb = options.upgrade ? ["install", "-U"] : ["install"];
         // 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
@@ -4259,21 +4373,145 @@ options = {}) {
                 ? [...verb, packageName]
                 : ["-m", "pip", ...verb, packageName],
         }));
-        const errors = [];
-        for (const candidate of pipCandidates) {
-            const pipResult = await safeSpawnAsync(candidate.command, candidate.args, {
-                timeout: 120_000,
-                ignoreAmbientSignal: true,
-                lifetimeCoupled: true,
+        const pep668 = /externally-managed-environment/i;
+        const refuse = (strategy, reason) => {
+            if (!pep668.test(reason))
+                return;
+            const subject = `${toolId}:${strategy}`;
+            recordDegradationOnce({
+                kind: "pip-pep668-strategy-refused",
+                subject,
+                reason,
             });
-            const outcome = {
-                ok: pipResult.status === 0,
-                error: (pipResult.error?.message ?? pipResult.stderr).trim(),
-            };
-            if (outcome.ok) {
-                // Ensure user-level scripts directory is available in current process PATH.
-                // This helps tools installed via `pip install --user` become immediately callable.
-                const userBaseResult = await new Promise((resolve) => {
+            const logKey = `${getDegradationLedgerGeneration()}:${subject}`;
+            if (pipPep668LoggedRefusals.current(logKey) === 0) {
+                pipPep668LoggedRefusals.bump(logKey);
+                logSessionStart(`auto-install pip ${packageName}: ${strategy} refused by PEP 668 (${boundInstallError(reason)})`);
+            }
+        };
+        const succeeded = (strategy, binaryPath) => {
+            recordDegradationOnce({
+                kind: "pip-install-strategy-succeeded",
+                subject: `${toolId}:${strategy}`,
+                reason: binaryPath,
+            });
+            return binaryPath;
+        };
+        const run = (command, args, env) => safeSpawnAsync(command, args, {
+            timeout: 120_000,
+            ignoreAmbientSignal: true,
+            lifetimeCoupled: true,
+            cwd: resolveToolCwd("runner", toolId, getGlobalPiLensDir(), {
+                cwd: getGlobalPiLensDir(),
+                suppressTelemetry: true,
+            }).cwd,
+            ...(env ? { env } : {}),
+        });
+        const addBinToPath = async (binDir) => {
+            try {
+                await fs.access(binDir);
+            }
+            catch {
+                return undefined;
+            }
+            const currentPath = process.env.PATH || process.env.Path || "";
+            const separator = isWindows ? ";" : path.delimiter;
+            if (!currentPath
+                .toLowerCase()
+                .split(separator)
+                .includes(binDir.toLowerCase())) {
+                const updatedPath = `${binDir}${separator}${currentPath}`;
+                process.env.PATH = updatedPath;
+                if (isWindows)
+                    process.env.Path = updatedPath;
+            }
+            const names = isWindows
+                ? [`${binaryName}.exe`, `${binaryName}.cmd`, binaryName]
+                : [binaryName];
+            for (const name of names) {
+                const candidate = path.join(binDir, name);
+                try {
+                    await fs.access(candidate);
+                    return candidate;
+                }
+                catch {
+                    // continue
+                }
+            }
+            return undefined;
+        };
+        if (await isCommandAvailable("pipx")) {
+            const result = await run("pipx", [
+                options.upgrade ? "upgrade" : "install",
+                packageName,
+            ]);
+            const error = (result.error?.message ?? result.stderr).trim();
+            if (result.status === 0) {
+                const location = await run("pipx", [
+                    "environment",
+                    "--value",
+                    "PIPX_BIN_DIR",
+                ]);
+                const binDir = location.status === 0 && location.stdout.trim()
+                    ? location.stdout.trim()
+                    : path.join(os.homedir(), ".local", "bin");
+                const binaryPath = await addBinToPath(binDir);
+                if (binaryPath)
+                    return succeeded("pipx", binaryPath);
+                throw new Error(`pipx installed ${packageName} but ${binaryName} is not resolvable`);
+            }
+            refuse("pipx", error);
+        }
+        const pythonCandidates = pipCandidates.filter(({ command }) => command === "python3" || command === "python" || command === "py");
+        const pythonAvailability = await Promise.all(pythonCandidates.map(({ command }) => isCommandAvailable(command)));
+        const availablePythonCandidates = pythonCandidates.filter((_, index) => pythonAvailability[index]);
+        const venvRoot = path.join(getGlobalPiLensDir(), "pip-tools");
+        for (const candidate of availablePythonCandidates) {
+            const venvBin = pipScriptsDir(venvRoot, installerPlatform());
+            let venvPip = path.join(venvBin, isWindows ? "pip.exe" : "pip");
+            try {
+                await fs.access(venvPip);
+            }
+            catch {
+                const created = await run(candidate.command, ["-m", "venv", venvRoot]);
+                const error = (created.error?.message ?? created.stderr).trim();
+                if (created.status !== 0) {
+                    refuse("venv", error || "python venv module unavailable");
+                    continue;
+                }
+            }
+            try {
+                await fs.access(venvPip);
+            }
+            catch {
+                venvPip = path.join(venvBin, isWindows ? "pip.cmd" : "pip3");
+                try {
+                    await fs.access(venvPip);
+                }
+                catch {
+                    continue;
+                }
+            }
+            const result = await run(venvPip, [...verb, packageName]);
+            const error = (result.error?.message ?? result.stderr).trim();
+            if (result.status === 0) {
+                const binaryPath = await addBinToPath(venvBin);
+                if (binaryPath)
+                    return succeeded("venv", binaryPath);
+                throw new Error(`venv installed ${packageName} but ${binaryName} is not resolvable`);
+            }
+            refuse("venv", error);
+        }
+        const candidateErrors = [];
+        let userRefused = false;
+        for (const candidate of pipCandidates) {
+            const args = candidate.command === "pip" || candidate.command === "pip3"
+                ? [...verb, "--user", packageName]
+                : ["-m", "pip", ...verb, "--user", packageName];
+            const result = await run(candidate.command, args);
+            const error = (result.error?.message ?? result.stderr).trim();
+            if (result.status === 0) {
+                const base = await new Promise((resolve) => {
                     let probe;
                     try {
                         probe = spawn(candidate.command, ["-m", "site", "--user-base"], {
@@ -4282,78 +4520,57 @@ options = {}) {
                         });
                     }
                     catch {
-                        // SYNCHRONOUS spawn throw (Windows `spawn UNKNOWN`/EINVAL, the
-                        // pidusage bug class, #533) — best-effort probe, resolve empty.
                         resolve("");
                         return;
                     }
                     let stdout = "";
                     probe.stdout?.on("data", (data) => (stdout += data));
-                    probe.on("exit", (code) => {
-                        if (code === 0)
-                            resolve(stdout.trim());
-                        else
-                            resolve("");
-                    });
+                    probe.on("exit", (code) => resolve(code === 0 ? stdout.trim() : ""));
                     probe.on("error", () => resolve(""));
                 });
-                if (userBaseResult) {
-                    const candidateScriptDirs = [
-                        path.join(userBaseResult, isWindows ? "Scripts" : "bin"),
-                    ];
-                    if (isWindows) {
-                        // Some Python setups report USER_BASE as ...\Roaming\Python,
-                        // while scripts live in ...\Roaming\Python\PythonXY\Scripts.
-                        try {
-                            const children = await fs.readdir(userBaseResult, {
-                                withFileTypes: true,
-                            });
-                            for (const entry of children) {
-                                if (!entry.isDirectory())
-                                    continue;
-                                if (!/^python\d+$/i.test(entry.name))
-                                    continue;
-                                candidateScriptDirs.push(path.join(userBaseResult, entry.name, "Scripts"));
-                            }
-                        }
-                        catch {
-                            // ignore
-                        }
-                    }
-                    const currentPath = process.env.PATH || process.env.Path || process.env.path || "";
-                    const separator = isWindows ? ";" : ":";
-                    const normalizedPath = currentPath
-                        .toLowerCase()
-                        .split(separator)
-                        .map((p) => p.trim());
-                    for (const scriptsDir of candidateScriptDirs) {
-                        try {
-                            await fs.access(scriptsDir);
-                            if (!normalizedPath.includes(scriptsDir.toLowerCase())) {
-                                const existingPath = process.env.PATH ||
-                                    process.env.Path ||
-                                    process.env.path ||
-                                    "";
-                                const updatedPath = `${scriptsDir}${separator}${existingPath}`;
-                                process.env.PATH = updatedPath;
-                                if (isWindows) {
-                                    process.env.Path = updatedPath;
-                                }
-                                debugLog(`Added pip user scripts dir to PATH: ${scriptsDir}`);
-                            }
-                        }
-                        catch {
-                            debugLog(`pip user scripts dir not accessible: ${scriptsDir}`);
-                        }
-                    }
-                }
-                return packageName;
+                const binaryPath = base
+                    ? await addBinToPath(pipScriptsDir(base, installerPlatform()))
+                    : undefined;
+                // Keep the historical normal-user result even when the interpreter's
+                // user-base probe is unavailable. The next availability probe owns
+                // resolution through PATH and its user-base candidates.
+                return succeeded("user", binaryPath ?? packageName);
+            }
+            const candidateError = `${candidate.command} ${args.join(" ")}: ${boundInstallError(error, INSTALL_CANDIDATE_ERROR_LIMIT)}`;
+            candidateErrors.push(candidateError);
+            if (pep668.test(error)) {
+                userRefused = true;
+                refuse("user", error);
+            }
+        }
+        if (!userRefused)
+            throw new Error(`pip install failed: ${candidateErrors.join(" | ") || "unknown error"}`);
+        const privateBase = path.join(getGlobalPiLensDir(), "pip-user");
+        const privateEnv = { ...process.env, PYTHONUSERBASE: privateBase };
+        for (const candidate of pipCandidates) {
+            const args = candidate.command === "pip" || candidate.command === "pip3"
+                ? [...verb, "--user", "--break-system-packages", packageName]
+                : [
+                    "-m",
+                    "pip",
+                    ...verb,
+                    "--user",
+                    "--break-system-packages",
+                    packageName,
+                ];
+            const result = await run(candidate.command, args, privateEnv);
+            const error = (result.error?.message ?? result.stderr).trim();
+            if (result.status !== 0) {
+                const candidateError = `${candidate.command} ${args.join(" ")}: ${boundInstallError(error, INSTALL_CANDIDATE_ERROR_LIMIT)}`;
+                candidateErrors.push(candidateError);
+                continue;
             }
-            const candidateError = `${candidate.command} ${candidate.args.join(" ")}: ${boundInstallError(outcome.error, INSTALL_CANDIDATE_ERROR_LIMIT)}`;
-            errors.push(candidateError);
-            debugLog(`[pip-fallback] ${candidateError}`);
+            const binaryPath = await addBinToPath(pipScriptsDir(privateBase, installerPlatform()));
+            if (binaryPath)
+                return succeeded("private-prefix", binaryPath);
+            throw new Error(`private-prefix pip installed ${packageName} but ${binaryName} is not resolvable`);
         }
-        throw new Error(`Failed to install ${packageName}: no usable pip command found (${errors.join(" | ") || "unknown error"})`);
+        throw new Error(`pip install failed: ${candidateErrors.join(" | ") || "unknown error"}`);
     }
     catch (err) {
         return recordPackageManagerInstallException(toolId, "pip", packageName, err);
@@ -4493,7 +4710,7 @@ export async function installTool(toolId) {
             case "pip": {
                 if (!tool.packageName)
                     return false;
-                const pipPath = await installPipTool(tool.id, tool.packageName);
+                const pipPath = await installPipTool(tool.id, tool.packageName, tool.binaryName ?? tool.id);
                 return finishInstallAttempt(tool.id, pipPath !== undefined, startedAt);
             }
             case "gem": {
@@ -4871,6 +5088,8 @@ export const GITHUB_TOOLS = [
     "clojure-lsp",
     "cue",
     "gleam",
+    "typstyle",
+    "tinymist",
     "marksman",
     "expert",
 ];

package/node_modules/pi-lens/dist/clients/instance-reaper-state.js

@@ -0,0 +1,7 @@
+/** Directory boundary for the backstop lock and cooldown stamp. Production
+ * shares the machine home; the test harness isolates only this state without
+ * relocating the registry, installed tools, or other machine-wide stores.
+ */
+export function resolveBackstopStateDir(machineHome) {
+    return machineHome;
+}