@herbertgao/pi-extensions 2026.8.6 → 2026.8.7

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

@@ -23,6 +23,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeFileAtomic, writeFileAtomicAsync } from "./atomic-write.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 // #735: reuse the #449/#525 reaper's exact conservative liveness check
 // (`process.kill(pid, 0)`, ESRCH-only-means-dead) rather than inventing a
@@ -57,6 +58,30 @@ export function _resetInstanceRegistryEnabledForTests() {
     _enabledCache = undefined;
 }
 // --- Read ---
+/**
+ * Distinguishes "no registry yet" (ENOENT — a genuinely clean start, never
+ * recorded) from "a registry file exists but couldn't be trusted" (corrupt
+ * JSON, wrong shape, or another read error — e.g. a torn write left behind by
+ * a killed process, #1609 layer b). Both degrade to `{ instances: [] }`
+ * either way (this store is purely observational, per the module docstring),
+ * but only the latter is worth recording — a clean empty start must never
+ * read the same as a corrupt one, or a genuine torn-file regression would be
+ * invisible.
+ *
+ * `readRegistrySync`/`readRegistryAsync` are called from many sites across a
+ * session (register/heartbeat/reap/footprint — not only session_start), so
+ * this goes through `recordDegradationOnce` (#1609 review, the small fix)
+ * rather than a plain log call: the ledger's own per-kind/subject dedup caps
+ * it at one record for the session regardless of how many times the same
+ * torn file gets re-read, instead of re-logging on every call.
+ */
+function recordCorruptRegistryRead(reasonCode) {
+    recordDegradationOnce({
+        kind: "instance-registry-corrupt",
+        subject: "instances.json",
+        reason: `read failed (${reasonCode}); treating as empty`,
+    });
+}
 function readRegistrySync() {
     try {
         const raw = fs.readFileSync(registryPath(), "utf-8");
@@ -64,10 +89,16 @@ function readRegistrySync() {
         if (parsed && Array.isArray(parsed.instances)) {
             return parsed;
         }
+        recordCorruptRegistryRead("invalid shape");
         return { instances: [] };
     }
-    catch {
-        // Missing file, corrupt JSON, or wrong shape — treat as empty, never throw.
+    catch (err) {
+        // Missing file, corrupt JSON, or a read error — treat as empty, never
+        // throw. Missing (ENOENT) is a clean start and stays silent; anything
+        // else is recorded so a corrupt/torn file is distinguishable from one.
+        const code = err?.code;
+        if (code !== "ENOENT")
+            recordCorruptRegistryRead(code ?? "invalid");
         return { instances: [] };
     }
 }
@@ -78,9 +109,13 @@ async function readRegistryAsync() {
         if (parsed && Array.isArray(parsed.instances)) {
             return parsed;
         }
+        recordCorruptRegistryRead("invalid shape");
         return { instances: [] };
     }
-    catch {
+    catch (err) {
+        const code = err?.code;
+        if (code !== "ENOENT")
+            recordCorruptRegistryRead(code ?? "invalid");
         return { instances: [] };
     }
 }
@@ -186,8 +221,32 @@ export async function updateHeartbeat(patch = {}) {
     };
     await writeRegistryAsync(file);
 }
+// Every mutation below (`recordLspChild`, `removeLspChild`) reads the WHOLE
+// registry file, edits this process's own `lspChildren`, and writes the whole
+// file back. Two such mutations from the SAME process — e.g. a client-ceiling
+// eviction's `removeLspChild(victimPid)` racing the replacement spawn's
+// `recordLspChild(newChild)` that follows it — are ordinary concurrent async
+// calls with no ordering guarantee between them. Without serialization, the
+// later WRITE can be built from a read taken before the earlier write landed,
+// silently reverting it (last-writer-wins losing a same-process update, not
+// just the already-accepted cross-process one — see the module docstring).
+// #1724: this is why a forced LSP shutdown's deregistration could get
+// clobbered by a concurrent respawn's registration. One shared tail
+// serializes every same-process registry mutation of this shape so "record"
+// and "remove" can never interleave their read-modify-write against each
+// other — the single seam both the forced-shutdown and self-crash
+// deregistration paths route through.
+let registryChildMutationTail = Promise.resolve();
+function queueRegistryChildMutation(op) {
+    const run = registryChildMutationTail.then(op);
+    registryChildMutationTail = run.catch(() => { });
+    return run;
+}
 /** Append/replace (by pid) an LSP child under this process's entry. */
-export async function recordLspChild(entry) {
+export function recordLspChild(entry) {
+    return queueRegistryChildMutation(() => recordLspChildNow(entry));
+}
+async function recordLspChildNow(entry) {
     if (!isInstanceRegistryEnabled())
         return;
     const pid = process.pid;
@@ -226,19 +285,23 @@ export async function recordLspChild(entry) {
     }
     await writeRegistryAsync(file);
 }
-// LSP client shutdown intentionally does not await registry removal (the
-// process-exiting path must stay non-blocking), but concurrent removals still
-// need to serialize their read-modify-write sequence or siblings can be lost
-// to last-writer-wins. Process kills remain fully concurrent; this queue only
-// covers the small best-effort registry mutation.
-let lspChildRemovalTail = Promise.resolve();
-/** Remove an LSP child (by pid) from this process's entry. */
-export function removeLspChild(pid) {
-    const removal = lspChildRemovalTail.then(() => removeLspChildNow(pid));
-    lspChildRemovalTail = removal.catch(() => { });
-    return removal;
+/**
+ * Remove an LSP child (by pid) from this process's entry. `expectedMarker`,
+ * when supplied, guards against the pid-recycling window between this
+ * child's death and this call landing: if the recorded entry for `pid` now
+ * carries a DIFFERENT marker than the one this caller spawned, some other
+ * child has already claimed that pid (recycled) and must not be removed on
+ * this caller's behalf — same asymmetric-safety contract as the reaper's
+ * `buildIdentityMatcher` (never remove on an unverifiable/mismatched
+ * identity). Omit `expectedMarker` for a server this process never derived a
+ * marker for (pid-only match, unchanged pre-#1724 behavior) — safe because
+ * this call fires synchronously off THIS process's own just-confirmed exit
+ * of that exact pid, well inside the OS's pid-reuse latency.
+ */
+export function removeLspChild(pid, expectedMarker) {
+    return queueRegistryChildMutation(() => removeLspChildNow(pid, expectedMarker));
 }
-async function removeLspChildNow(pid) {
+async function removeLspChildNow(pid, expectedMarker) {
     if (!isInstanceRegistryEnabled())
         return;
     const selfPid = process.pid;
@@ -247,7 +310,14 @@ async function removeLspChildNow(pid) {
     if (idx === -1)
         return;
     const current = file.instances[idx];
-    const filtered = current.lspChildren.filter((child) => child.pid !== pid);
+    const filtered = current.lspChildren.filter((child) => {
+        if (child.pid !== pid)
+            return true; // keep — different pid
+        if (expectedMarker && child.marker && child.marker !== expectedMarker) {
+            return true; // keep — pid recycled onto a differently-marked child
+        }
+        return false; // drop — this is the child we're deregistering
+    });
     if (filtered.length === current.lspChildren.length)
         return; // nothing removed
     file.instances[idx] = {

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

@@ -7,7 +7,9 @@
  * Requires: npm install -D jscpd
  * Docs: https://github.com/kucherenko/jscpd
  */
+import { formatToolFailure } from "./dispatch/runners/utils/tool-failure.js";
 import { createSubsystemLogger } from "./extension-log.js";
+import { incrementDegradationCount } from "./degradation-ledger.js";
 import * as fs from "node:fs";
 import { mkdtempSync } from "node:fs";
 import * as os from "node:os";
@@ -27,6 +29,31 @@ const EMPTY_RESULT = {
     percentage: 0,
 };
 const SCAN_TIMEOUT_MS = 30_000;
+/** jscpd's own config-file names, in its discovery order, checked at `cwd` only
+ * (jscpd does not walk up). */
+const JSCPD_CONFIG_FILENAMES = [".jscpd.json", "jscpd.json"];
+/**
+ * True when the project ships its own jscpd config: a `.jscpd.json`/
+ * `jscpd.json` file, or a `package.json` `jscpd` field. jscpd discovers either
+ * unaided, but `--min-lines`/`--min-tokens`/`--ignore` on the CLI override
+ * whatever the config sets — passing them unconditionally silently discarded a
+ * project's own thresholds and ignore list (#1731, discipline A).
+ */
+function hasProjectJscpdConfig(cwd) {
+    for (const name of JSCPD_CONFIG_FILENAMES) {
+        if (fs.existsSync(path.join(cwd, name)))
+            return true;
+    }
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
+        if (pkg && typeof pkg === "object" && pkg.jscpd !== undefined)
+            return true;
+    }
+    catch {
+        // No/malformed package.json — "no project config" is the honest answer.
+    }
+    return false;
+}
 const jscpdAvailability = createAvailabilityChecker("jscpd", "", ["--version"], {
     probeTimeout: 1500,
     // One definition of the managed-shim fast path, shared with knip (#1476).
@@ -109,6 +136,22 @@ export class JscpdClient {
             this.jscpdManagedPath = resolved;
         return true;
     }
+    /**
+     * #1623: public availability verdict for callers outside the dispatch
+     * graph (mode=full's fresh-fetch) that need to say WHY `ensureAvailable()`
+     * most recently returned false, using the SAME outcome/cause the shared
+     * `jscpdAvailability` checker already tracks — not a re-guessed "jscpd
+     * binary unavailable" that can't tell a transient retry-cooldown probe
+     * from a durable absence.
+     */
+    getAvailabilityVerdict() {
+        const verdict = jscpdAvailability.getVerdict(process.cwd());
+        return {
+            outcome: verdict.outcome,
+            cause: verdict.cause,
+            retryAtMs: verdict.retryAtMs,
+        };
+    }
     /**
      * Scan a directory for duplicate code blocks.
      * Uses a temp output dir to capture JSON report.
@@ -183,19 +226,21 @@ export class JscpdClient {
                 : this.jscpdManagedPath
                     ? { cmd: this.jscpdManagedPath, prefix: [] }
                     : { cmd: "npx", prefix: ["jscpd"] };
+            // A project's own jscpd config wins outright (#1731, discipline A):
+            // these three flags all override whatever it sets, so none are passed
+            // when the project ships one — jscpd discovers it unaided.
+            const hasConfig = hasProjectJscpdConfig(cwd);
             const result = await safeSpawnAsync(cmd, [
                 ...prefix,
                 ".",
-                "--min-lines",
-                String(minLines),
-                "--min-tokens",
-                String(minTokens),
+                ...(hasConfig
+                    ? []
+                    : ["--min-lines", String(minLines), "--min-tokens", String(minTokens)]),
                 "--reporters",
                 "json",
                 "--output",
                 outDir,
-                "--ignore",
-                ignorePattern,
+                ...(hasConfig ? [] : ["--ignore", ignorePattern]),
             ], {
                 timeout: SCAN_TIMEOUT_MS,
                 cwd,
@@ -204,8 +249,39 @@ export class JscpdClient {
                 this.log(`Scan error: ${result.error.message}`);
                 return { ...EMPTY_RESULT };
             }
+            // Empirical exit-code table (jscpd 3.5.10, verified live for #1736's
+            // sweep): a genuinely clean run (no clones) exits 0 and writes NO
+            // report file — jscpd only writes `jscpd-report.json` when it has
+            // something to report. A crashed run (uncaught exception, e.g. a bad
+            // scan path) ALSO writes no report file, but exits nonzero. The
+            // missing-file check alone can't tell those apart, so a nonzero exit
+            // with no report file is reported as errored, never as "0 clones".
+            // (Not `spawnFailedWithNoOutput` — the parsed artifact here is a
+            // report FILE, not stdout, so the shared stdout-based discriminator
+            // doesn't apply; the underlying "nonzero exit -> not clean" rule is
+            // the same one.)
             const reportPath = path.join(outDir, "jscpd-report.json");
             if (!fs.existsSync(reportPath)) {
+                if (result.status !== 0) {
+                    // #1816: one shared wording, one truncation, signal named.
+                    // `reportMissing` is the artifact-tool arm of the same
+                    // primitive — the parsed artifact here is a report FILE.
+                    const reason = formatToolFailure({
+                        tool: "jscpd",
+                        status: result.status,
+                        signal: result.signal,
+                        stderr: result.stderr,
+                        reportMissing: true,
+                        fields: { command: cmd },
+                    });
+                    this.log(reason);
+                    incrementDegradationCount({
+                        kind: "runner-empty-result",
+                        subject: "jscpd",
+                        reason,
+                    });
+                    return { ...EMPTY_RESULT };
+                }
                 return { ...EMPTY_RESULT, success: true };
             }
             return this.parseReport(reportPath);