@herbertgao/pi-extensions 2026.9.0 → 2026.9.2

package/node_modules/pi-lens/dist/clients/installer/managed-tool-refresh.js

@@ -45,6 +45,8 @@
  */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
+import { bounded } from "../deadline-utils.js";
 import { recordDegradationOnce } from "../degradation-ledger.js";
 import { commitDurableStoreAsync } from "../durable-store.js";
 import { pmBinary, resolveNodePackageManager, updateArgs, } from "../package-manager.js";
@@ -263,9 +265,28 @@ async function installedRefreshCandidates() {
             verificationTimeoutMs: tool.verificationTimeoutMs ?? 10_000,
             ...(tool.packageName !== undefined && { packageName: tool.packageName }),
             ...(tool.binaryName !== undefined && { binaryName: tool.binaryName }),
+            ...(tool.packageEntryOf !== undefined && {
+                packageEntryOf: tool.packageEntryOf,
+            }),
         });
     }
-    return candidates;
+    const byPackage = new Map();
+    const distinct = [];
+    for (const candidate of candidates) {
+        if (candidate.strategy !== "npm" || !candidate.packageName) {
+            distinct.push(candidate);
+            continue;
+        }
+        const existing = byPackage.get(candidate.packageName);
+        if (existing) {
+            existing.coveredToolIds?.push(candidate.toolId);
+            continue;
+        }
+        const representative = { ...candidate, coveredToolIds: [candidate.toolId] };
+        byPackage.set(candidate.packageName, representative);
+        distinct.push(representative);
+    }
+    return distinct;
 }
 /**
  * Which candidates are due, oldest stamp first. A tool with no stamp sorts
@@ -276,15 +297,17 @@ export function selectStaleTools(candidates, state, now) {
     const interval = refreshIntervalMs();
     const retry = retryIntervalMs();
     const due = candidates.filter((candidate) => {
-        const entry = state.tools[candidate.toolId];
-        if (!entry)
-            return true;
-        const cooldown = entry.failed ? retry : interval;
-        return now - entry.checkedAt >= cooldown;
+        return (candidate.coveredToolIds ?? [candidate.toolId]).some((toolId) => {
+            const entry = state.tools[toolId];
+            if (!entry)
+                return true;
+            const cooldown = entry.failed ? retry : interval;
+            return now - entry.checkedAt >= cooldown;
+        });
     });
     return due.sort((a, b) => {
-        const aAt = state.tools[a.toolId]?.checkedAt ?? 0;
-        const bAt = state.tools[b.toolId]?.checkedAt ?? 0;
+        const aAt = Math.min(...(a.coveredToolIds ?? [a.toolId]).map((toolId) => state.tools[toolId]?.checkedAt ?? 0));
+        const bAt = Math.min(...(b.coveredToolIds ?? [b.toolId]).map((toolId) => state.tools[toolId]?.checkedAt ?? 0));
         return aAt !== bAt ? aAt - bAt : a.toolId.localeCompare(b.toolId);
     });
 }
@@ -346,6 +369,7 @@ async function refreshNonNpmOne(candidate, entry, now) {
                 changed: false,
                 verified: false,
                 ok: false,
+                attempted: false,
             };
         }
         // A real failure may have left a stale cached path or probe entry behind
@@ -383,6 +407,7 @@ async function refreshNonNpmOne(candidate, entry, now) {
             // touched the installed copy, so there is nothing new to check.
             verified: false,
             ok: false,
+            attempted: true,
         };
     }
     const currentVersion = attempt.version;
@@ -412,6 +437,7 @@ async function refreshNonNpmOne(candidate, entry, now) {
         // probe for pip/gem) — `ok: true` here already means "and it runs".
         verified: true,
         ok: true,
+        attempted: true,
     };
 }
 async function refreshNpmOne(candidate, now) {
@@ -435,6 +461,7 @@ async function refreshNpmOne(candidate, now) {
             changed: false,
             verified: false,
             ok: false,
+            attempted: false,
         };
     }
     try {
@@ -468,6 +495,7 @@ async function performNpmRefresh(candidate, packageName, now) {
     const elapsedMs = Date.now() - startedAt;
     if (spawned.status !== 0 || spawned.error) {
         const reason = (spawned.error?.message ?? spawned.stderr ?? "").slice(0, 200);
+        const coveredIds = candidate.coveredToolIds?.join(",") ?? candidate.toolId;
         // "Keeping <old version>" would be an unchecked assertion (#1746 review
         // F2). The spawn budget kills the package manager where it stands, which
         // can be mid-write: the tree may hold a new version, a half-written one,
@@ -479,9 +507,9 @@ async function performNpmRefresh(candidate, packageName, now) {
         recordDegradationOnce({
             kind: "managed-tool-refresh",
             subject: candidate.toolId,
-            reason: `${pm} update failed: ${reason || "non-zero exit"}`,
+            reason: `package ${packageName}, covered ids ${coveredIds}; ${pm} update failed: ${reason || "non-zero exit"}`,
         });
-        logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update failed after ${elapsedMs}ms — on disk now ${onDisk ?? "unreadable"} (was ${previousVersion ?? "unknown"}); resolution cache cleared for re-probe (${reason || "non-zero exit"})`);
+        logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update failed after ${elapsedMs}ms — package ${packageName}, covered ids ${coveredIds}; on disk now ${onDisk ?? "unreadable"} (was ${previousVersion ?? "unknown"}); resolution cache cleared for re-probe (${reason || "non-zero exit"})`);
         await writeRefreshStamp(candidate.toolId, {
             checkedAt: now,
             failed: true,
@@ -496,6 +524,7 @@ async function performNpmRefresh(candidate, packageName, now) {
             changed: onDisk !== undefined && onDisk !== previousVersion,
             verified: false,
             ok: false,
+            attempted: true,
         };
     }
     const currentVersion = await readInstalledVersion(packageName);
@@ -515,12 +544,17 @@ async function performNpmRefresh(candidate, packageName, now) {
     // drops npm entries that do not.
     const binaryName = candidate.binaryName;
     const binPath = resolveManagedNpmBinPath(binaryName);
-    const verified = await verifyToolBinary(binPath, undefined, undefined, candidate.verificationTimeoutMs, candidate.checkArgs);
+    const verified = await verifyToolBinary(binPath, undefined, undefined, candidate.verificationTimeoutMs, candidate.checkArgs, 
+    // #2722: the same verification the install used. Without this the daily
+    // refresh would demand a `--version` verdict from a server that can never
+    // give one — a ~4 MB doomed spawn that stamps the refresh failed forever.
+    candidate.packageEntryOf);
     if (!verified) {
+        const coveredIds = candidate.coveredToolIds?.join(",") ?? candidate.toolId;
         recordDegradationOnce({
             kind: "managed-tool-refresh",
             subject: candidate.toolId,
-            reason: `binary failed verification after ${pm} update (${previousVersion ?? "unknown"} → ${currentVersion ?? "unknown"})`,
+            reason: `package ${packageName}, covered ids ${coveredIds}; binary failed verification after ${pm} update (${previousVersion ?? "unknown"} → ${currentVersion ?? "unknown"})`,
         });
         // Deliberately NOT removed. `installNpmTool` deletes a freshly installed
         // package that fails verification because nothing was working before it;
@@ -528,7 +562,7 @@ async function performNpmRefresh(candidate, packageName, now) {
         // offline for certain rather than probably. The cache invalidation above is
         // what lets `ensureTool`'s own probe-and-repair path see the breakage and
         // reinstall. Stamped as failed so the shorter retry cooldown applies.
-        logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update ran but ${binPath} failed verification — resolution cache cleared for re-probe (${elapsedMs}ms)`);
+        logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update ran but ${binPath} failed verification — package ${packageName}, covered ids ${coveredIds}; resolution cache cleared for re-probe (${elapsedMs}ms)`);
         await writeRefreshStamp(candidate.toolId, {
             checkedAt: now,
             failed: true,
@@ -543,6 +577,7 @@ async function performNpmRefresh(candidate, packageName, now) {
             changed,
             verified: false,
             ok: false,
+            attempted: true,
         };
     }
     await writeRefreshStamp(candidate.toolId, {
@@ -552,8 +587,8 @@ async function performNpmRefresh(candidate, packageName, now) {
     // The observability row #1730 asks for: a wrong verdict from a managed tool
     // can be traced to the version that produced it, and to the moment it moved.
     logSessionStart(changed
-        ? `managed-tool-refresh ${candidate.toolId}: ${previousVersion ?? "unknown"} → ${currentVersion} via ${pm} update, verified (${elapsedMs}ms)`
-        : `managed-tool-refresh ${candidate.toolId}: unchanged at ${currentVersion ?? previousVersion ?? "unknown"} (${elapsedMs}ms)`);
+        ? `managed-tool-refresh ${candidate.toolId}: ${previousVersion ?? "unknown"} → ${currentVersion} via ${pm} update, verified; package ${packageName}, covered ids ${candidate.coveredToolIds?.join(",") ?? candidate.toolId} (${elapsedMs}ms)`
+        : `managed-tool-refresh ${candidate.toolId}: unchanged at ${currentVersion ?? previousVersion ?? "unknown"}; package ${packageName}, covered ids ${candidate.coveredToolIds?.join(",") ?? candidate.toolId} (${elapsedMs}ms)`);
     return {
         toolId: candidate.toolId,
         strategy: "npm",
@@ -563,6 +598,7 @@ async function performNpmRefresh(candidate, packageName, now) {
         changed,
         verified: true,
         ok: true,
+        attempted: true,
     };
 }
 /**
@@ -682,13 +718,22 @@ async function executeManagedToolRefresh(now, tap = noopTap) {
         // `/new` calls walked the entire 22-tool stale list. A local allowance
         // cannot be re-armed by anyone: a mid-run reset restores the SESSION's
         // right to start a new run, which is correct, without extending this one.
-        const want = Math.min(maxPerSession(), stale.length);
+        const stalePackages = new Set();
+        const distinctStale = stale.filter((candidate) => {
+            if (candidate.strategy !== "npm" || !candidate.packageName)
+                return true;
+            if (stalePackages.has(candidate.packageName))
+                return false;
+            stalePackages.add(candidate.packageName);
+            return true;
+        });
+        const want = Math.min(maxPerSession(), distinctStale.length);
         while (held < want && reserveManagedToolRefreshSlot(maxPerSession())) {
             held += 1;
         }
         let allowance = held;
         const refreshed = [];
-        for (const candidate of stale) {
+        for (const candidate of distinctStale) {
             // Once a spawn happens the slot is spent for good — a failing tool must
             // not hand its slot to the next candidate and turn a budget of one into
             // 22 spawns.
@@ -697,7 +742,28 @@ async function executeManagedToolRefresh(now, tap = noopTap) {
             allowance -= 1;
             held -= 1;
             try {
-                refreshed.push(await refreshOne(candidate, read.state.tools[candidate.toolId], now));
+                const result = await refreshOne(candidate, read.state.tools[candidate.toolId], now);
+                refreshed.push(result);
+                if (result.attempted && candidate.coveredToolIds) {
+                    for (const toolId of candidate.coveredToolIds) {
+                        if (toolId === candidate.toolId)
+                            continue;
+                        await bounded(writeRefreshStamp(toolId, {
+                            checkedAt: now,
+                            ...(result.currentVersion !== undefined && {
+                                version: result.currentVersion,
+                            }),
+                            ...(result.ok ? {} : { failed: true }),
+                        }), {
+                            ms: HOOK_WALL_BUDGET_MS.session_start,
+                            // The unref'd timer runs after session_start returns, so no
+                            // live turn signal belongs to this background refresh.
+                            signal: undefined,
+                            hook: "session_start",
+                            label: "writeRefreshStamp:covered-tool",
+                        });
+                    }
+                }
                 await tap();
             }
             catch (err) {