@herbertgao/pi-extensions 2026.8.3 → 2026.8.5

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

@@ -64,6 +64,9 @@ export const STALE_HEARTBEAT_MS = 6 * 60 * 60 * 1000;
 import { spawn as nodeSpawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { writeFileAtomicAsync } from "./atomic-write.js";
+import { sweepOwnStagingFiles, } from "./atomic-write-staging.js";
+import { spawnCollectStdout, unrefChildAndPipes } from "./child-unref.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 import { isInstanceRegistryEnabled, readInstanceRegistry, } from "./instance-registry.js";
 import { logLatency } from "./latency-logger.js";
@@ -149,7 +152,10 @@ function classifyDeadInstanceChildren(instance, isPidAlive, matchProcess, liveMa
         // process (e.g. the native exe grandchild) by command-line match.
         // Never surface a marker a live instance also claims (see above).
         if (child.marker && !liveMarkers.has(child.marker)) {
-            out.markerSearches.push({ marker: child.marker, serverId: child.serverId });
+            out.markerSearches.push({
+                marker: child.marker,
+                serverId: child.serverId,
+            });
         }
     }
 }
@@ -218,6 +224,29 @@ export function realIsPidAlive(pid) {
         return true;
     }
 }
+/** Maximum number of directory entries inspected by one staging sweep. */
+export const ATOMIC_STAGE_SWEEP_MAX_ENTRIES = 512;
+/**
+ * Remove orphaned generic atomic-write staging files from pi-lens-owned
+ * directories. This is deliberately a directory-entry sweep, not a watcher:
+ * it runs from session_start, reads at most `maxEntries` entries per directory,
+ * and never creates a process-lifetime handle.
+ *
+ * Safety invariants:
+ * - only the three atomic-write `.tmp-<pid>[-<thread>[-<seq>]]` shapes match;
+ * - directories and symlinks are never removed;
+ * - this process's pid is always protected, and every foreign pid is checked
+ *   through the reaper's conservative ESRCH-only liveness seam;
+ * - every I/O failure is best-effort and cannot fail session_start.
+ */
+export async function sweepAtomicWriteStages(directories, options = {}) {
+    const requestedMax = options.maxEntries ?? ATOMIC_STAGE_SWEEP_MAX_ENTRIES;
+    const maxEntries = Number.isFinite(requestedMax)
+        ? Math.max(1, Math.floor(requestedMax))
+        : ATOMIC_STAGE_SWEEP_MAX_ENTRIES;
+    const isPidAlive = options.isPidAlive ?? realIsPidAlive;
+    return sweepOwnStagingFiles(directories, { maxEntries, isPidAlive });
+}
 function windowsExe(name) {
     return path.join(process.env.SystemRoot ?? String.raw `C:\Windows`, "System32", name);
 }
@@ -249,27 +278,12 @@ async function findPidsByMarkerWindows(marker) {
     const psScript = `Get-CimInstance Win32_Process -Filter "CommandLine LIKE '%${escaped}%'" ` +
         `| Where-Object { $_.ProcessId -ne $PID } ` +
         `| Select-Object -ExpandProperty ProcessId`;
-    return new Promise((resolve) => {
-        try {
-            const powershell = windowsExe("WindowsPowerShell\\v1.0\\powershell.exe");
-            const child = nodeSpawn(powershell, ["-NoProfile", "-NonInteractive", "-Command", psScript], { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
-            let out = "";
-            child.stdout?.on("data", (chunk) => {
-                out += chunk.toString();
-            });
-            child.once("error", () => resolve([]));
-            child.once("close", () => {
-                const pids = out
-                    .split(/\r?\n/)
-                    .map((line) => Number(line.trim()))
-                    .filter((n) => Number.isFinite(n) && n > 0);
-                resolve(pids);
-            });
-        }
-        catch {
-            resolve([]);
-        }
-    });
+    const powershell = windowsExe("WindowsPowerShell\\v1.0\\powershell.exe");
+    const out = await spawnCollectStdout(powershell, ["-NoProfile", "-NonInteractive", "-Command", psScript], { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
+    return out
+        .split(/\r?\n/)
+        .map((line) => Number(line.trim()))
+        .filter((n) => Number.isFinite(n) && n > 0);
 }
 /** Fetch command lines for a set of pids in one query (Windows: CIM; POSIX:
  *  `ps`). Returns a pid → command-line map; pids that can't be resolved are
@@ -284,68 +298,40 @@ async function queryCommandLines(pids) {
         const filter = valid.map((p) => `ProcessId=${p}`).join(" OR ");
         const psScript = `Get-CimInstance Win32_Process -Filter "${filter}" ` +
             `| ForEach-Object { "$($_.ProcessId)\t$($_.CommandLine)" }`;
-        return new Promise((resolve) => {
-            try {
-                const powershell = windowsExe("WindowsPowerShell\\v1.0\\powershell.exe");
-                const child = nodeSpawn(powershell, ["-NoProfile", "-NonInteractive", "-Command", psScript], { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
-                let out = "";
-                child.stdout?.on("data", (chunk) => {
-                    out += chunk.toString();
-                });
-                child.once("error", () => resolve(map));
-                child.once("close", () => {
-                    for (const line of out.split(/\r?\n/)) {
-                        const tab = line.indexOf("\t");
-                        if (tab <= 0)
-                            continue;
-                        const pid = Number(line.slice(0, tab).trim());
-                        if (Number.isFinite(pid) && pid > 0)
-                            map.set(pid, line.slice(tab + 1));
-                    }
-                    resolve(map);
-                });
-            }
-            catch {
-                resolve(map);
-            }
-        });
-    }
-    return new Promise((resolve) => {
-        try {
-            const child = nodeSpawn(posixPsPath(), ["-p", valid.join(","), "-o", "pid=,args="], { shell: false, stdio: ["ignore", "pipe", "ignore"] });
-            let out = "";
-            child.stdout?.on("data", (chunk) => {
-                out += chunk.toString();
-            });
-            child.once("error", () => resolve(map));
-            child.once("close", () => {
-                for (const line of out.split(/\r?\n/)) {
-                    // Linear parse (S8786/S6594: avoid regex backtracking on
-                    // attacker-lengthenable ps output) — trim leading whitespace,
-                    // then split on the first whitespace run: "  1234 args here".
-                    const trimmed = line.trimStart();
-                    if (!trimmed)
-                        continue;
-                    let i = 0;
-                    while (i < trimmed.length && trimmed[i] >= "0" && trimmed[i] <= "9")
-                        i++;
-                    if (i === 0)
-                        continue;
-                    const pidStr = trimmed.slice(0, i);
-                    let j = i;
-                    while (j < trimmed.length && (trimmed[j] === " " || trimmed[j] === "\t"))
-                        j++;
-                    const pid = Number(pidStr);
-                    if (Number.isFinite(pid) && pid > 0)
-                        map.set(pid, trimmed.slice(j));
-                }
-                resolve(map);
-            });
-        }
-        catch {
-            resolve(map);
+        const powershell = windowsExe("WindowsPowerShell\\v1.0\\powershell.exe");
+        const out = await spawnCollectStdout(powershell, ["-NoProfile", "-NonInteractive", "-Command", psScript], { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
+        for (const line of out.split(/\r?\n/)) {
+            const tab = line.indexOf("\t");
+            if (tab <= 0)
+                continue;
+            const pid = Number(line.slice(0, tab).trim());
+            if (Number.isFinite(pid) && pid > 0)
+                map.set(pid, line.slice(tab + 1));
         }
-    });
+        return map;
+    }
+    const out = await spawnCollectStdout(posixPsPath(), ["-p", valid.join(","), "-o", "pid=,args="], { shell: false, stdio: ["ignore", "pipe", "ignore"] });
+    for (const line of out.split(/\r?\n/)) {
+        // Linear parse (S8786/S6594: avoid regex backtracking on
+        // attacker-lengthenable ps output) — trim leading whitespace,
+        // then split on the first whitespace run: "  1234 args here".
+        const trimmed = line.trimStart();
+        if (!trimmed)
+            continue;
+        let i = 0;
+        while (i < trimmed.length && trimmed[i] >= "0" && trimmed[i] <= "9")
+            i++;
+        if (i === 0)
+            continue;
+        const pidStr = trimmed.slice(0, i);
+        let j = i;
+        while (j < trimmed.length && (trimmed[j] === " " || trimmed[j] === "\t"))
+            j++;
+        const pid = Number(pidStr);
+        if (Number.isFinite(pid) && pid > 0)
+            map.set(pid, trimmed.slice(j));
+    }
+    return map;
 }
 /**
  * Build a `matchProcess` identity predicate from a pid → command-line map
@@ -387,6 +373,7 @@ async function killPidTree(pid) {
                 windowsHide: true,
                 stdio: "ignore",
             });
+            unrefChildAndPipes(killer);
             await new Promise((resolve) => {
                 killer.once("close", () => resolve());
                 killer.once("error", () => resolve());
@@ -484,94 +471,63 @@ async function enumerateManagedProcesses() {
         const clauses = MANAGED_BINARY_NAMES.map((name) => `CommandLine LIKE '%${escapeWqlLikeValue(name)}%'`).join(" OR ");
         const psScript = `Get-CimInstance Win32_Process -Filter "${clauses}" ` +
             `| ForEach-Object { "$($_.ProcessId)\t$($_.ParentProcessId)\t$($_.CommandLine)" }`;
-        return new Promise((resolve) => {
-            try {
-                const powershell = windowsExe("WindowsPowerShell\\v1.0\\powershell.exe");
-                const child = nodeSpawn(powershell, ["-NoProfile", "-NonInteractive", "-Command", psScript], { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
-                let out = "";
-                child.stdout?.on("data", (chunk) => {
-                    out += chunk.toString();
-                });
-                child.once("error", () => resolve([]));
-                child.once("close", () => {
-                    const results = [];
-                    for (const line of out.split(/\r?\n/)) {
-                        const firstTab = line.indexOf("\t");
-                        if (firstTab <= 0)
-                            continue;
-                        const secondTab = line.indexOf("\t", firstTab + 1);
-                        if (secondTab <= 0)
-                            continue;
-                        const pid = Number(line.slice(0, firstTab).trim());
-                        const parentPid = Number(line.slice(firstTab + 1, secondTab).trim());
-                        const command = line.slice(secondTab + 1);
-                        if (Number.isFinite(pid) && pid > 0) {
-                            results.push({ pid, parentPid, command });
-                        }
-                    }
-                    resolve(results);
-                });
-            }
-            catch {
-                resolve([]);
+        const powershell = windowsExe("WindowsPowerShell\\v1.0\\powershell.exe");
+        const out = await spawnCollectStdout(powershell, ["-NoProfile", "-NonInteractive", "-Command", psScript], { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
+        const results = [];
+        for (const line of out.split(/\r?\n/)) {
+            const firstTab = line.indexOf("\t");
+            if (firstTab <= 0)
+                continue;
+            const secondTab = line.indexOf("\t", firstTab + 1);
+            if (secondTab <= 0)
+                continue;
+            const pid = Number(line.slice(0, firstTab).trim());
+            const parentPid = Number(line.slice(firstTab + 1, secondTab).trim());
+            const command = line.slice(secondTab + 1);
+            if (Number.isFinite(pid) && pid > 0) {
+                results.push({ pid, parentPid, command });
             }
-        });
+        }
+        return results;
     }
     // POSIX: enumerate everything, filter in JS by managed-name substring —
     // there is no single-query WQL-style server-side filter available.
-    return new Promise((resolve) => {
-        try {
-            const child = nodeSpawn(posixPsPath(), ["-eo", "pid=,ppid=,args="], {
-                shell: false,
-                stdio: ["ignore", "pipe", "ignore"],
-            });
-            let out = "";
-            child.stdout?.on("data", (chunk) => {
-                out += chunk.toString();
-            });
-            child.once("error", () => resolve([]));
-            child.once("close", () => {
-                const results = [];
-                for (const line of out.split(/\r?\n/)) {
-                    // Linear parse (S8786/S6594): "  pid ppid args here".
-                    const trimmed = line.trimStart();
-                    if (!trimmed)
-                        continue;
-                    let i = 0;
-                    while (i < trimmed.length && trimmed[i] >= "0" && trimmed[i] <= "9")
-                        i++;
-                    if (i === 0)
-                        continue;
-                    const pid = Number(trimmed.slice(0, i));
-                    let rest = trimmed.slice(i);
-                    let k = 0;
-                    while (k < rest.length && (rest[k] === " " || rest[k] === "\t"))
-                        k++;
-                    rest = rest.slice(k);
-                    let j = 0;
-                    while (j < rest.length && rest[j] >= "0" && rest[j] <= "9")
-                        j++;
-                    if (j === 0)
-                        continue;
-                    const parentPid = Number(rest.slice(0, j));
-                    let m = j;
-                    while (m < rest.length && (rest[m] === " " || rest[m] === "\t"))
-                        m++;
-                    const args = rest.slice(m);
-                    if (!Number.isFinite(pid) || pid <= 0)
-                        continue;
-                    const lowerArgs = args.toLowerCase();
-                    if (MANAGED_BINARY_NAMES.some((name) => lowerArgs.includes(name.toLowerCase()))) {
-                        results.push({ pid, parentPid, command: args });
-                    }
-                }
-                resolve(results);
-            });
-        }
-        catch {
-            resolve([]);
+    const out = await spawnCollectStdout(posixPsPath(), ["-eo", "pid=,ppid=,args="], { shell: false, stdio: ["ignore", "pipe", "ignore"] });
+    const results = [];
+    for (const line of out.split(/\r?\n/)) {
+        // Linear parse (S8786/S6594): "  pid ppid args here".
+        const trimmed = line.trimStart();
+        if (!trimmed)
+            continue;
+        let i = 0;
+        while (i < trimmed.length && trimmed[i] >= "0" && trimmed[i] <= "9")
+            i++;
+        if (i === 0)
+            continue;
+        const pid = Number(trimmed.slice(0, i));
+        let rest = trimmed.slice(i);
+        let k = 0;
+        while (k < rest.length && (rest[k] === " " || rest[k] === "\t"))
+            k++;
+        rest = rest.slice(k);
+        let j = 0;
+        while (j < rest.length && rest[j] >= "0" && rest[j] <= "9")
+            j++;
+        if (j === 0)
+            continue;
+        const parentPid = Number(rest.slice(0, j));
+        let m = j;
+        while (m < rest.length && (rest[m] === " " || rest[m] === "\t"))
+            m++;
+        const args = rest.slice(m);
+        if (!Number.isFinite(pid) || pid <= 0)
+            continue;
+        const lowerArgs = args.toLowerCase();
+        if (MANAGED_BINARY_NAMES.some((name) => lowerArgs.includes(name.toLowerCase()))) {
+            results.push({ pid, parentPid, command: args });
         }
-    });
+    }
+    return results;
 }
 /**
  * Fire-and-forget REGISTRY-INDEPENDENT backstop sweep (#658): finds
@@ -682,7 +638,8 @@ export async function sweepOrphans() {
         // Entry removal covers BOTH sets: pid-dead instances AND stale-heartbeat
         // (pid-alive) instances — the latter is record cleanup only (#525);
         // nothing belonging to a stale instance was killed above.
-        if (decision.deadInstances.length > 0 || decision.staleInstances.length > 0) {
+        if (decision.deadInstances.length > 0 ||
+            decision.staleInstances.length > 0) {
             try {
                 const prunePids = new Set([
                     ...decision.deadInstances.map((i) => i.pid),
@@ -721,8 +678,23 @@ export async function sweepOrphans() {
  *  instances from the registry. Re-reads immediately before
  *  writing (rather than reusing the earlier `readInstanceRegistry()` snapshot)
  *  to narrow — not eliminate — the last-writer-wins race already accepted for
- *  slice 1's read-modify-write model. */
-async function pruneDeadInstances(deadPids) {
+ *  slice 1's read-modify-write model.
+ *
+ *  Exported for the #1217 concurrency regression test; `sweepOrphans` is the
+ *  only production caller.
+ *
+ *  #1217: this used to hand-roll `${target}.tmp-${process.pid}` + rename
+ *  instead of going through `atomic-write.ts`, so it never inherited the
+ *  #1205 fix — two concurrent prunes in one process staged into one shared
+ *  inode and the first rename published it while the second was still
+ *  writing. That is reachable here rather than theoretical: this store is
+ *  machine-global and written fire-and-forget from `instance-registry.ts`'s
+ *  `prunePids` as well, and `readInstanceRegistry` degrades a parse failure
+ *  to empty, so a tear dropped EVERY registered instance rather than one
+ *  entry. `writeFileAtomicAsync` also cleans up its staging file on a failed
+ *  rename, which the hand-rolled copy did not, and puts this writer back on
+ *  the same scheme as the other writer of this same file. */
+export async function pruneDeadInstances(deadPids) {
     const target = path.join(getGlobalPiLensDir(), "instances.json");
     try {
         const raw = await fs.promises.readFile(target, "utf-8");
@@ -732,10 +704,8 @@ async function pruneDeadInstances(deadPids) {
         const remaining = parsed.instances.filter((entry) => !deadPids.has(entry.pid));
         if (remaining.length === parsed.instances.length)
             return;
-        const tmpPath = `${target}.tmp-${process.pid}`;
         await fs.promises.mkdir(getGlobalPiLensDir(), { recursive: true });
-        await fs.promises.writeFile(tmpPath, JSON.stringify({ instances: remaining }), "utf-8");
-        await fs.promises.rename(tmpPath, target);
+        await writeFileAtomicAsync(target, JSON.stringify({ instances: remaining }));
     }
     catch {
         // best-effort

package/node_modules/pi-lens/dist/clients/jscpd-client.js

@@ -7,14 +7,16 @@
  * Requires: npm install -D jscpd
  * Docs: https://github.com/kucherenko/jscpd
  */
+import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import { mkdtempSync } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { getExcludedDirGlobs, getGlobalPiLensDir, getProjectIgnoreGlobs, getProjectIgnoreMatcher, } from "./file-utils.js";
 import { findNodeToolBinary } from "./package-manager.js";
-import { isAtOrAboveHomeDir } from "./path-utils.js";
+import { isAtOrAboveHomeDir, isFullyQualified } from "./path-utils.js";
 import { getJscpdMaxEntriesDerived } from "./project-scale.js";
+import { createAvailabilityChecker, resolveAvailableOrInstall } from "./dispatch/runners/utils/runner-helpers.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import { shouldRecurseIntoDir, walkTreeStackSync } from "./source-walker.js";
 const EMPTY_RESULT = {
@@ -25,14 +27,30 @@ const EMPTY_RESULT = {
     percentage: 0,
 };
 const SCAN_TIMEOUT_MS = 30_000;
+const jscpdAvailability = createAvailabilityChecker("jscpd", "", ["--version"], {
+    probeTimeout: 1500,
+    fastPath: () => {
+        const localBase = path.join(getGlobalPiLensDir(), "tools", "node_modules", ".bin", "jscpd");
+        const candidates = process.platform === "win32"
+            ? [`${localBase}.cmd`, `${localBase}.exe`, localBase]
+            : [localBase];
+        return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
+    },
+});
 // --- Client ---
 export class JscpdClient {
-    available = null;
-    ensureInFlight = null;
+    // Absolute path of a MANAGED jscpd (the global ~/.pi-lens tools shim
+    // discovered by the availability fast path, or the ensureTool install
+    // result), else null. Nullable on purpose: a bare-name sentinel can't
+    // distinguish "resolved" from "on PATH" — ensureTool may legitimately
+    // return a bare command for an already-spawnable tool (#1289 review).
+    // Project-local binaries are NOT stored; each scan resolves those against
+    // its own cwd via findNodeToolBinary.
+    jscpdManagedPath = null;
     inFlight = new Map();
     log;
     constructor(verbose = false) {
-        this.log = verbose ? (msg) => console.error(`[jscpd] ${msg}`) : () => { };
+        this.log = verbose ? createSubsystemLogger("jscpd") : () => { };
     }
     /**
      * Fast recursive source file presence check.
@@ -89,55 +107,12 @@ export class JscpdClient {
      * Check if jscpd is available, auto-install if not
      */
     async ensureAvailable() {
-        // Fast path: already checked
-        if (this.available !== null)
-            return this.available;
-        // Deduplicate concurrent calls
-        if (this.ensureInFlight)
-            return this.ensureInFlight;
-        this.ensureInFlight = this.doEnsureAvailable();
-        try {
-            return await this.ensureInFlight;
-        }
-        finally {
-            this.ensureInFlight = null;
-        }
-    }
-    async doEnsureAvailable() {
-        // Fast path: check local install before any spawn
-        const isWin = process.platform === "win32";
-        const localBase = path.join(getGlobalPiLensDir(), "tools", "node_modules", ".bin", "jscpd");
-        const localCandidates = isWin
-            ? [`${localBase}.cmd`, `${localBase}.exe`, localBase]
-            : [localBase];
-        for (const candidate of localCandidates) {
-            try {
-                if (fs.existsSync(candidate)) {
-                    this.available = true;
-                    return true;
-                }
-            }
-            catch {
-                // continue
-            }
-        }
-        // Check if available in PATH (short timeout — if not instantly available, it's not in PATH)
-        const result = await safeSpawnAsync("jscpd", ["--version"], {
-            timeout: 1500,
-        });
-        this.available = !result.error && result.status === 0;
-        if (this.available) {
-            return true;
-        }
-        // Auto-install via pi-lens installer
-        const { ensureTool } = await import("./installer/index.js");
-        const installedPath = await ensureTool("jscpd");
-        if (installedPath) {
-            this.available = true;
-            return true;
-        }
-        this.available = false;
-        return false;
+        const resolved = await resolveAvailableOrInstall(jscpdAvailability, "jscpd", process.cwd());
+        if (!resolved)
+            return false;
+        if (isFullyQualified(resolved))
+            this.jscpdManagedPath = resolved;
+        return true;
     }
     /**
      * Scan a directory for duplicate code blocks.
@@ -210,7 +185,9 @@ export class JscpdClient {
             const bin = await findNodeToolBinary("jscpd", cwd);
             const { cmd, prefix } = bin
                 ? { cmd: bin, prefix: [] }
-                : { cmd: "npx", prefix: ["jscpd"] };
+                : this.jscpdManagedPath
+                    ? { cmd: this.jscpdManagedPath, prefix: [] }
+                    : { cmd: "npx", prefix: ["jscpd"] };
             const result = await safeSpawnAsync(cmd, [
                 ...prefix,
                 ".",

package/node_modules/pi-lens/dist/clients/knip-client.js

@@ -8,11 +8,13 @@
  * Requires: npm install -D knip
  * Docs: https://knip.dev/
  */
+import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getProjectDataDir } from "./file-utils.js";
 import { findNearestMarkerRoot } from "./path-utils.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+import { createAvailabilityChecker, getManagedToolEnvironment, resolveAvailableOrInstall, } from "./dispatch/runners/utils/runner-helpers.js";
 const EMPTY_RESULT = {
     success: false,
     issues: [],
@@ -56,7 +58,12 @@ export function readOverridePinnedPackageNames(targetDir) {
 }
 // --- Client ---
 export class KnipClient {
+    knipAvailability = createAvailabilityChecker("knip", ".cmd", ["--version"], {
+        environment: (cwd) => getManagedToolEnvironment("knip", cwd),
+        unclassifiedFailureOutcome: "missing",
+    });
     knipAvailable = null;
+    knipCommand = "knip";
     ensureInFlight = null;
     log;
     /**
@@ -75,7 +82,7 @@ export class KnipClient {
     inFlight = new Map();
     constructor(verbose = false) {
         this.log = verbose
-            ? (msg) => console.error(`[knip] ${msg}`)
+            ? createSubsystemLogger("knip")
             : () => { };
     }
     /**
@@ -114,26 +121,11 @@ export class KnipClient {
         }
     }
     async doEnsureAvailable() {
-        // Check if available in PATH (fast)
-        const pathResult = await safeSpawnAsync("knip", ["--version"], {
-            timeout: 5000,
-        });
-        if (!pathResult.error && pathResult.status === 0) {
-            this.knipAvailable = true;
-            this.log("Knip found in PATH");
-            return true;
-        }
-        // Auto-install via pi-lens installer
-        this.log("Knip not found, attempting auto-install...");
-        const { ensureTool } = await import("./installer/index.js");
-        const installedPath = await ensureTool("knip");
-        if (installedPath) {
-            this.knipAvailable = true;
-            this.log(`Knip auto-installed: ${installedPath}`);
-            return true;
-        }
-        this.knipAvailable = false;
-        return false;
+        const resolved = await resolveAvailableOrInstall(this.knipAvailability, "knip", process.cwd());
+        this.knipAvailable = resolved !== null;
+        if (resolved)
+            this.knipCommand = resolved;
+        return this.knipAvailable;
     }
     /**
      * Run knip analysis on the project.
@@ -213,10 +205,10 @@ export class KnipClient {
             "--cache-location",
             cacheLocation,
         ];
-        const result = await safeSpawnAsync("knip", args, {
+        const result = await safeSpawnAsync(this.knipCommand, args, {
             timeout: ANALYSIS_TIMEOUT_MS,
             cwd: targetDir,
-            env: await this.getKnipEnvironment(targetDir),
+            env: await getManagedToolEnvironment("knip", targetDir),
         });
         if (result.error) {
             this.log(`Analysis error: ${result.error.message}`);
@@ -271,19 +263,6 @@ export class KnipClient {
             ? result
             : { ...result, issues, unusedDeps };
     }
-    async getKnipEnvironment(targetDir) {
-        const { getToolEnvironment } = await import("./installer/index.js");
-        const env = await getToolEnvironment();
-        const separator = process.platform === "win32" ? ";" : ":";
-        const currentPath = env.PATH || env.Path || process.env.PATH || "";
-        const localBin = path.join(targetDir, "node_modules", ".bin");
-        const augmentedPath = `${localBin}${separator}${currentPath}`;
-        return {
-            ...env,
-            PATH: augmentedPath,
-            ...(process.platform === "win32" ? { Path: augmentedPath } : {}),
-        };
-    }
     /**
      * Find unused exports in a specific file
      */