pi-lens 4.1.2 → 4.1.4

package/dist/clients/workspace-topology.js

@@ -39,13 +39,25 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { PROJECT_CONFIG_BASENAMES } from "./config-locations.js";
 import { logLatency } from "./latency-logger.js";
 import { isAtOrAboveHomeDir, nameMatchesMarkerGlob, walkUpDirs, } from "./path-utils.js";
 /** Depth cap on any upward marker walk — mirrors `findNearestMarkerRoot`'s bound. */
 const MAX_WALK_DEPTH = 64;
-const PI_LENS_CONFIG_BASENAMES = [".pi-lens.json", "pi-lens.json"];
+/**
+ * The project config basenames, canonical first — the SHARED table, not a
+ * fourth copy of the pair (#2426 review round 2). `config-locations.ts` derives
+ * it from the one location table the resolver walks, so a change there cannot
+ * leave this marker index preferring a different file than the loaders do.
+ */
+const PI_LENS_CONFIG_BASENAMES = PROJECT_CONFIG_BASENAMES;
 /** Per-directory marker cache — the shared seam every consumer reads through. */
 const dirMarkerCache = new Map();
+/** Downstream memo clears that must follow the topology index reset. */
+const topologyDerivedCacheResets = [];
+export function registerWorkspaceTopologyReset(reset) {
+    topologyDerivedCacheResets.push(reset);
+}
 const walkCache = new Map();
 const TOPOLOGY_MAX_DIR_ENTRIES = 256;
 const TOPOLOGY_MAX_WALK_ENTRIES = 512;
@@ -95,6 +107,8 @@ export function resetWorkspaceTopology() {
         deleteDirMarker(key);
     for (const key of walkCache.keys())
         deleteWalk(key);
+    for (const reset of topologyDerivedCacheResets)
+        reset();
 }
 /**
  * Release cache eviction handles without discarding reusable entries.
@@ -182,6 +196,11 @@ export function getDirectoryMarkers(dir) {
         chartYamlPath: resolveMarker("Chart.yaml"),
     };
     const entry = { dirMtimeMs, markers, lastUsedAt: Date.now() };
+    const outgoing = dirMarkerCache.get(resolvedDir);
+    if (outgoing?.idleTimer !== undefined) {
+        clearTimeout(outgoing.idleTimer);
+        outgoing.idleTimer = undefined;
+    }
     dirMarkerCache.set(resolvedDir, entry);
     touchDirMarker(resolvedDir, entry);
     while (dirMarkerCache.size > TOPOLOGY_MAX_DIR_ENTRIES) {
@@ -243,6 +262,11 @@ function walkToNearestMatch(startDir, cacheSuffix, matches, capMetadata, homeDir
         dirMtimes,
         lastUsedAt: Date.now(),
     };
+    const outgoing = walkCache.get(key);
+    if (outgoing?.idleTimer !== undefined) {
+        clearTimeout(outgoing.idleTimer);
+        outgoing.idleTimer = undefined;
+    }
     walkCache.set(key, entry);
     touchWalk(key, entry);
     while (walkCache.size > TOPOLOGY_MAX_WALK_ENTRIES) {

package/dist/clients/zizmor-config.js

@@ -21,6 +21,9 @@ export const LOCAL_ZIZMOR_CONFIG_NAMES = [
     "zizmor.yml",
     "zizmor.yaml",
 ];
+// Deliberately UNCEILINGED at $HOME (refs #2472 review round 3, F1): a
+// user-level `~/zizmor.yml` (or `~/.github/zizmor.yml`) is a legitimate
+// global config, not an escaped-workspace accident.
 export function findLocalZizmorConfig(startDir) {
     return findLocalToolConfig(startDir, LOCAL_ZIZMOR_CONFIG_NAMES);
 }
@@ -131,20 +134,28 @@ function classifyGhTokenFailure(res, hostStallMs) {
         // The process ran to completion with a real (nonzero, since the zero
         // exit is handled before this is ever called) exit code — a genuine
         // "not authenticated" (or otherwise rejected) answer, safe to cache.
-        return { outcome: "non-installable", cause: "probe-rejected" };
+        return {
+            outcome: "non-installable",
+            cause: "probe-rejected",
+            classifiedBy: "caller",
+        };
     }
     if (res.spawnFailure?.kind === "tool-not-found") {
         // gh genuinely isn't on PATH — a durable fact about the machine.
-        return { outcome: "missing", cause: "not-found" };
+        return { outcome: "missing", cause: "not-found", classifiedBy: "caller" };
     }
     const classified = classifyProbeFailure(res, { hostStallMs });
     if (classified.outcome === "transient" || classified.outcome === "missing") {
-        return classified;
+        return { ...classified, classifiedBy: "probe" };
     }
     // Everything else (EACCES/permission-denied, cwd-unresolvable, a generic
     // spawn-failed, or an unrecognized errno) means the child never launched —
     // that's evidence about this moment, not about gh's auth state.
-    return { outcome: "transient", cause: classified.cause };
+    return {
+        outcome: "transient",
+        cause: classified.cause,
+        classifiedBy: "caller",
+    };
 }
 async function deriveGhCliToken() {
     const sampler = startHostStallSampler();
@@ -173,6 +184,7 @@ async function deriveGhCliToken() {
                 latched: true,
                 hostStallMs,
                 budgetMs: GH_TOKEN_PROBE_TIMEOUT_MS,
+                classifiedBy: "probe",
             });
             return token;
         }
@@ -183,7 +195,11 @@ async function deriveGhCliToken() {
         // regardless of whether `token` was empty, so the record claimed the
         // online audits ran while zizmor was actually about to launch offline
         // — the #1535 silence moved into the telemetry instead of being fixed.
-        return recordGhTokenUnavailable({ outcome: "non-installable", cause: "empty-result" }, elapsedMs, hostStallMs);
+        return recordGhTokenUnavailable({
+            outcome: "non-installable",
+            cause: "empty-result",
+            classifiedBy: "caller",
+        }, elapsedMs, hostStallMs);
     }
     return recordGhTokenUnavailable(classifyGhTokenFailure(res, hostStallMs), elapsedMs, hostStallMs);
 }
@@ -193,7 +209,7 @@ async function deriveGhCliToken() {
  * and logs the decision. Centralized so the empty-answer and failure paths
  * can't drift on which fields get set.
  */
-function recordGhTokenUnavailable({ outcome, cause, }, elapsedMs, hostStallMs) {
+function recordGhTokenUnavailable({ outcome, cause, classifiedBy }, elapsedMs, hostStallMs) {
     const retryAfterMs = ghTokenLatch.noteUnavailable(outcome, cause);
     if (outcome === "transient") {
         recordZizmorOfflineDegradation(`gh auth token probe ${cause}; running offline until the next zizmor start (retry allowed in ${Math.round(retryAfterMs / 1000)}s)`);
@@ -208,6 +224,10 @@ function recordGhTokenUnavailable({ outcome, cause, }, elapsedMs, hostStallMs) {
         hostStallMs,
         ...(retryAfterMs > 0 && { retryAfterMs }),
         budgetMs: GH_TOKEN_PROBE_TIMEOUT_MS,
+        // Shared tail for both call paths; the caller carries whether ITS
+        // own verdict was a `classifyProbeFailure` passthrough or one of
+        // this module's own assertions (#2226 review F2).
+        classifiedBy,
     });
     return undefined;
 }
@@ -295,6 +315,9 @@ export async function resolveZizmorGitHubToken() {
                 hostStallMs: 0,
                 ...(retryAfterMs > 0 && { retryAfterMs }),
                 budgetMs: GH_TOKEN_PROBE_TIMEOUT_MS,
+                // No probe ran here: the latch's own remembered cause is replayed
+                // as-is, so the call site is the one asserting it (#2209).
+                classifiedBy: "caller",
             });
         }
         return memo ? cachedToken : undefined;