pi-lens 3.8.67 → 3.8.68

package/dist/clients/instance-registry.js

@@ -0,0 +1,238 @@
+/**
+ * Cross-process instance registry (#449 slice 1).
+ *
+ * Observability substrate for multi-agent LSP resource sharing. Records, in
+ * a single machine-global file (`~/.pi-lens/instances.json`), every live
+ * pi-lens process: its pid, project root, live LSP child servers, RSS, and a
+ * heartbeat timestamp. Later slices (cross-process budget, same-root warm
+ * attach) build on this; slice 1 is purely observational — it changes no
+ * dispatch/LSP behavior, it only records state and reaps stale entries /
+ * orphaned LSP children (#472).
+ *
+ * File shape: `{ instances: InstanceEntry[] }`. Missing or corrupt file is
+ * treated as `{ instances: [] }` — this module must never throw on a read.
+ *
+ * Concurrency: every write is read-modify-write-whole-file with an atomic
+ * tmp+rename (same pattern as clients/review-graph/builder.ts). Two
+ * processes racing a write is a KNOWN, ACCEPTED race for slice 1
+ * (last-writer-wins) — a lost update here only means a stale/missing
+ * observability entry, never data corruption (the tmp+rename guarantees the
+ * file itself is always valid JSON). A future slice can add file locking or
+ * per-pid shard files if this proves too lossy in practice.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getGlobalPiLensDir } from "./file-utils.js";
+import { normalizeFilePath } from "./path-utils.js";
+function registryPath() {
+    return path.join(getGlobalPiLensDir(), "instances.json");
+}
+// --- Kill switch (lazy, memoized — house style per clients/runtime-config.ts) ---
+let _enabledCache;
+/**
+ * `PI_LENS_INSTANCE_REGISTRY=0` disables the registry entirely: every
+ * exported function in this module becomes a no-op (including the reaper
+ * sweep in clients/instance-reaper.ts, which checks this too).
+ */
+export function isInstanceRegistryEnabled() {
+    if (_enabledCache !== undefined)
+        return _enabledCache;
+    _enabledCache = process.env.PI_LENS_INSTANCE_REGISTRY !== "0";
+    return _enabledCache;
+}
+/** Test-only: clear the memoized kill-switch read. */
+export function _resetInstanceRegistryEnabledForTests() {
+    _enabledCache = undefined;
+}
+// --- Read ---
+function readRegistrySync() {
+    try {
+        const raw = fs.readFileSync(registryPath(), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && Array.isArray(parsed.instances)) {
+            return parsed;
+        }
+        return { instances: [] };
+    }
+    catch {
+        // Missing file, corrupt JSON, or wrong shape — treat as empty, never throw.
+        return { instances: [] };
+    }
+}
+async function readRegistryAsync() {
+    try {
+        const raw = await fs.promises.readFile(registryPath(), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && Array.isArray(parsed.instances)) {
+            return parsed;
+        }
+        return { instances: [] };
+    }
+    catch {
+        return { instances: [] };
+    }
+}
+/** Read-only snapshot of the whole registry (used by the reaper). */
+export async function readInstanceRegistry() {
+    const file = await readRegistryAsync();
+    return file.instances;
+}
+// --- Write (atomic tmp + rename, same pattern as review-graph/builder.ts) ---
+async function writeRegistryAsync(file) {
+    const dir = getGlobalPiLensDir();
+    const target = registryPath();
+    const tmpPath = `${target}.tmp-${process.pid}`;
+    try {
+        await fs.promises.mkdir(dir, { recursive: true });
+        await fs.promises.writeFile(tmpPath, JSON.stringify(file), "utf-8");
+        await fs.promises.rename(tmpPath, target);
+    }
+    catch {
+        // Best-effort observability substrate — a failed write just means this
+        // update is lost, never a thrown error for the caller.
+        try {
+            await fs.promises.rm(tmpPath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+function writeRegistrySync(file) {
+    const dir = getGlobalPiLensDir();
+    const target = registryPath();
+    const tmpPath = `${target}.tmp-${process.pid}`;
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(tmpPath, JSON.stringify(file), "utf-8");
+        fs.renameSync(tmpPath, target);
+    }
+    catch {
+        try {
+            fs.rmSync(tmpPath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+// --- Mutations (all read-modify-write whole file) ---
+/** Create/overwrite this process's entry. */
+export async function registerInstance(projectRoot) {
+    if (!isInstanceRegistryEnabled())
+        return;
+    const pid = process.pid;
+    const normalizedRoot = normalizeFilePath(projectRoot);
+    const file = await readRegistryAsync();
+    const now = new Date().toISOString();
+    const others = file.instances.filter((entry) => entry.pid !== pid);
+    const existing = file.instances.find((entry) => entry.pid === pid);
+    others.push({
+        pid,
+        startedAt: existing?.startedAt ?? now,
+        projectRoot: normalizedRoot,
+        lspChildren: existing?.lspChildren ?? [],
+        lspChildCount: existing?.lspChildren?.length ?? 0,
+        rssBytes: process.memoryUsage().rss,
+        heartbeatAt: now,
+    });
+    await writeRegistryAsync({ instances: others });
+}
+/** Update this process's heartbeat/rss. Cheap — safe to call every turn end. */
+export async function updateHeartbeat(patch = {}) {
+    if (!isInstanceRegistryEnabled())
+        return;
+    const pid = process.pid;
+    const file = await readRegistryAsync();
+    const idx = file.instances.findIndex((entry) => entry.pid === pid);
+    if (idx === -1) {
+        // No prior registerInstance in this run (e.g. registry file was reaped
+        // out from under us, or heartbeat fired before session_start finished) —
+        // nothing to update against; skip rather than fabricate a projectRoot.
+        return;
+    }
+    const now = new Date().toISOString();
+    const current = file.instances[idx];
+    file.instances[idx] = {
+        ...current,
+        rssBytes: patch.rssBytes ?? process.memoryUsage().rss,
+        lspChildCount: current.lspChildren.length,
+        heartbeatAt: now,
+    };
+    await writeRegistryAsync(file);
+}
+/** Append/replace (by pid) an LSP child under this process's entry. */
+export async function recordLspChild(entry) {
+    if (!isInstanceRegistryEnabled())
+        return;
+    const pid = process.pid;
+    const file = await readRegistryAsync();
+    const idx = file.instances.findIndex((inst) => inst.pid === pid);
+    const now = new Date().toISOString();
+    const childEntry = {
+        pid: entry.pid,
+        serverId: entry.serverId,
+        command: entry.command,
+        marker: entry.marker,
+        spawnedAt: now,
+    };
+    if (idx === -1) {
+        // registerInstance hasn't run yet in this process (or was reaped) —
+        // synthesize a minimal entry so the child is still tracked.
+        file.instances.push({
+            pid,
+            startedAt: now,
+            projectRoot: normalizeFilePath(process.cwd()),
+            lspChildren: [childEntry],
+            lspChildCount: 1,
+            rssBytes: process.memoryUsage().rss,
+            heartbeatAt: now,
+        });
+    }
+    else {
+        const current = file.instances[idx];
+        const filtered = current.lspChildren.filter((child) => child.pid !== entry.pid);
+        filtered.push(childEntry);
+        file.instances[idx] = {
+            ...current,
+            lspChildren: filtered,
+            lspChildCount: filtered.length,
+        };
+    }
+    await writeRegistryAsync(file);
+}
+/** Remove an LSP child (by pid) from this process's entry. */
+export async function removeLspChild(pid) {
+    if (!isInstanceRegistryEnabled())
+        return;
+    const selfPid = process.pid;
+    const file = await readRegistryAsync();
+    const idx = file.instances.findIndex((inst) => inst.pid === selfPid);
+    if (idx === -1)
+        return;
+    const current = file.instances[idx];
+    const filtered = current.lspChildren.filter((child) => child.pid !== pid);
+    if (filtered.length === current.lspChildren.length)
+        return; // nothing removed
+    file.instances[idx] = {
+        ...current,
+        lspChildren: filtered,
+        lspChildCount: filtered.length,
+    };
+    await writeRegistryAsync(file);
+}
+/**
+ * Remove this process's entry entirely. SYNC fs only — safe to call from
+ * `session_shutdown` (#234: no child spawns permitted at teardown; this
+ * function spawns nothing).
+ */
+export function deregisterInstance() {
+    if (!isInstanceRegistryEnabled())
+        return;
+    const pid = process.pid;
+    const file = readRegistrySync();
+    const remaining = file.instances.filter((entry) => entry.pid !== pid);
+    if (remaining.length === file.instances.length)
+        return; // nothing to remove
+    writeRegistrySync({ instances: remaining });
+}

package/dist/clients/lsp/client.js

@@ -10,6 +10,7 @@
 import { spawn as nodeSpawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { access, readFile } from "node:fs/promises";
+import * as os from "node:os";
 import { pathToFileURL } from "node:url";
 import { withTimeout } from "../deadline-utils.js";
 import { logLatency } from "../latency-logger.js";
@@ -18,6 +19,7 @@ import { logLatency } from "../latency-logger.js";
 import { CancellationTokenSource, createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "../deps/vscode-jsonrpc.js";
 import { getAmbientAbortSignal } from "../safe-spawn.js";
 import { applyWorkspaceEdit } from "./edits.js";
+import { recordLspChild, removeLspChild } from "../instance-registry.js";
 import { normalizeMapKey, uriToPath } from "./path-utils.js";
 import { ADVERTISED_POSITION_ENCODINGS, convertCharacterOffset, lineTextAt, negotiatePositionEncoding, } from "./position-encoding.js";
 import { getStrategy } from "./server-strategies.js";
@@ -27,6 +29,32 @@ import { WatchedFilesQueue } from "./watch-queue.js";
 // diagnose the clean-file affirmative-signal question (#240): which servers
 // publish an empty-with-version set on a clean scan vs go silent.
 const PUB_DEBUG = Boolean(process.env.PILENS_PUB_DEBUG);
+/**
+ * #472/#449: extract a per-spawn-unique "marker" from an LSP server's resolved
+ * args, for the instance registry's command-line re-identification fallback
+ * (used when a recorded child's pid is dead/recycled but its process tree
+ * grandchild — e.g. ast-grep's native exe behind a dead node wrapper — is
+ * still alive under a different pid).
+ *
+ * Generalized, NOT ast-grep-specific (uniformity requirement — no per-server
+ * special casing): the value immediately following a `--config`/`-c` flag, if
+ * that value looks like a path under a temp directory (`os.tmpdir()`). This
+ * covers ast-grep's `lsp --config <tmp sgconfig path>` (clients/sgconfig.ts)
+ * today, and any other server later launched with a temp-file `--config`/`-c`
+ * argument, without new server-specific code.
+ */
+function extractSpawnMarker(args) {
+    const tmpDir = os.tmpdir();
+    for (let i = 0; i < args.length - 1; i++) {
+        const flag = args[i];
+        if (flag === "--config" || flag === "-c") {
+            const value = args[i + 1];
+            if (value?.startsWith(tmpDir))
+                return value;
+        }
+    }
+    return undefined;
+}
 // --- Constants ---
 const INITIALIZE_TIMEOUT_MS = positiveIntFromEnv("PI_LENS_LSP_INIT_TIMEOUT_MS", 15_000); // 15s — npx downloads are handled by ensureTool, not here
 /**
@@ -158,8 +186,24 @@ export async function killProcessTree(proc, pid, options = {}) {
         // Host process is exiting (loop already closing): never spawn a child here —
         // the spawn's uv_async_send on the closing loop-wakeup handle hard-aborts
         // (src\win\async.c). Kill the direct child via the handle we already hold
-        // (TerminateProcess; synchronous, no async handle). Orphaned grandchildren
-        // are reaped by the OS as the host exits.
+        // (TerminateProcess; synchronous, no async handle).
+        //
+        // #472 CORRECTION of a prior false claim here ("orphaned grandchildren are
+        // reaped by the OS as the host exits"): Windows does NOT kill children when
+        // a parent dies. For shell/.cmd-wrapped servers the direct child is
+        // cmd.exe, so this path only ever kills the wrapper — the actual server
+        // (its grandchild) survives by design whenever it doesn't independently
+        // exit. It relies entirely on best-effort backstops instead: (1) the
+        // server observing stdin EOF once the wrapper's pipes close, (2) LSP
+        // `initialize.processId: process.pid` (some servers self-watchdog on that
+        // pid dying — typescript-language-server does, ast-grep's native binary
+        // does not, an upstream spec violation), and (3) the #449/#472
+        // cross-process instance registry's orphan reaper, which is the only
+        // mechanism that works regardless of why a pipe write-end stayed open
+        // (e.g. Windows handle-inheritance capture by a long-lived process). This
+        // is why registering every LSP child at spawn matters uniformly — do NOT
+        // weaken this direct-child-only kill to try to chase grandchildren here;
+        // spawning taskkill in this branch is exactly the libuv hazard above.
         if (options.processExiting) {
             try {
                 proc.kill();
@@ -751,6 +795,14 @@ export async function clientShutdown(state, options = {}) {
     }
     disposeClientConnection(state);
     const pid = state.lspProcess.pid;
+    // #449/#472: deregister this LSP child from the instance registry. Fire-
+    // and-forget (async fs, no spawn) — must not add latency/risk to shutdown,
+    // including the `processExiting` path where the event loop is closing
+    // (#234 forbids spawning here, but a plain fs write/rename is fine; even
+    // so, we don't await it to keep this teardown path as fast as before).
+    void removeLspChild(pid).catch(() => {
+        // best-effort — a stale entry is caught dead-pid by the reaper later
+    });
     // On Windows, killing the direct child first can orphan grandchildren before
     // taskkill can traverse the tree. Kill the full tree first and wait briefly.
     await killProcessTree(state.lspProcess.process, pid, options);
@@ -883,6 +935,21 @@ async function resolveCodeActionBestEffort(state, action) {
 export async function createLSPClient(options) {
     installCrashGuard();
     const { serverId, process: lspProcess, root, initialization, initializeTimeoutMs = INITIALIZE_TIMEOUT_MS, } = options;
+    // #449/#472: register this LSP child in the cross-process instance registry
+    // as soon as we have a live pid — BEFORE `initialize` completes, not after.
+    // Registering early means a child that dies/hangs during initialize (the
+    // catch block below kills it) is still deregistered by that same path via
+    // removeLspChild, and a process that crashes mid-initialize is still
+    // visible to the orphan reaper rather than silently untracked. Fire-and-
+    // forget: registry I/O must never block or fail LSP startup.
+    void recordLspChild({
+        pid: lspProcess.pid,
+        serverId,
+        command: lspProcess.command,
+        marker: extractSpawnMarker(lspProcess.args),
+    }).catch(() => {
+        // best-effort observability — never fail LSP startup over this
+    });
     const startupState = {
         exitCode: null,
         exitSignal: null,
@@ -1009,6 +1076,13 @@ export async function createLSPClient(options) {
         // SIGTERM alone is unreliable on Windows for cmd.exe/PowerShell trees.
         const pid = lspProcess.pid;
         void killProcessTree(lspProcess.process, pid);
+        // A child registered above (recordLspChild) but never reaching a healthy
+        // createLSPClient return must still be deregistered here — otherwise the
+        // registry keeps a stale entry for a process we just killed.
+        void removeLspChild(pid).catch(() => {
+            // best-effort — a stale registry entry is harmless (the reaper's
+            // liveness check will find it dead on the next sweep regardless)
+        });
         setTimeout(() => {
             if (!lspProcess.process.killed && process.platform !== "win32") {
                 lspProcess.process.kill("SIGKILL");

package/dist/clients/lsp/launch.js

@@ -566,6 +566,8 @@ export async function launchLSP(command, args = [], options = {}) {
         stdout: proc.stdout,
         stderr: proc.stderr,
         pid: proc.pid ?? 0,
+        command: spawnCommand,
+        args,
     };
 }
 /**

package/dist/clients/lsp/server-strategies.js

@@ -6,6 +6,67 @@
  *
  * Env var overrides (PI_LENS_LSP_*) always take precedence over strategy values.
  */
+import { createRequire } from "node:module";
+const _require = createRequire(import.meta.url);
+/**
+ * Platform/arch → `@ast-grep/cli-<platform>-<arch>[-msvc|-gnu]` native
+ * package name, mirroring @ast-grep/cli's own `optionalDependencies` matrix
+ * (checked directly against node_modules/@ast-grep/cli/package.json). Each
+ * package ships the native `ast-grep`/`ast-grep.exe` binary at its package
+ * root (no `bin/` subdir) — see node_modules/@ast-grep/cli-win32-x64-msvc/.
+ */
+function astGrepNativePackageName(platform, arch) {
+    switch (platform) {
+        case "win32":
+            if (arch === "x64")
+                return "@ast-grep/cli-win32-x64-msvc";
+            if (arch === "arm64")
+                return "@ast-grep/cli-win32-arm64-msvc";
+            if (arch === "ia32")
+                return "@ast-grep/cli-win32-ia32-msvc";
+            return undefined;
+        case "darwin":
+            if (arch === "arm64")
+                return "@ast-grep/cli-darwin-arm64";
+            if (arch === "x64")
+                return "@ast-grep/cli-darwin-x64";
+            return undefined;
+        case "linux":
+            if (arch === "x64")
+                return "@ast-grep/cli-linux-x64-gnu";
+            if (arch === "arm64")
+                return "@ast-grep/cli-linux-arm64-gnu";
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Resolve ast-grep's platform-native exe DIRECTLY, skipping the node-bin
+ * wrapper (`ast-grep.cmd`/shim → node → cli.js → spawn native exe). One less
+ * orphanable process layer (#472): a wrapper's direct child is the node/cmd
+ * process, so on abnormal exit the actual ast-grep binary is a grandchild the
+ * #234 teardown path never reaches — resolving straight to the native exe
+ * means the LSP's direct child IS the real server.
+ *
+ * `require.resolve` is wrapped in try/catch (ESM-safe via createRequire, same
+ * pattern as clients/deps/ast-grep-napi.ts) — returns undefined so the caller
+ * falls back to the existing wrapper-based resolution when the platform
+ * package isn't installed (it's an optionalDependency; native builds can be
+ * absent on unsupported platforms/arches or a partial install).
+ */
+export function resolveAstGrepNativeExe(platform = process.platform, arch = process.arch) {
+    const pkgName = astGrepNativePackageName(platform, arch);
+    if (!pkgName)
+        return undefined;
+    const binaryName = platform === "win32" ? "ast-grep.exe" : "ast-grep";
+    try {
+        return _require.resolve(`${pkgName}/${binaryName}`);
+    }
+    catch {
+        return undefined;
+    }
+}
 export const SERVER_DIAGNOSTIC_STRATEGIES = {
     typescript: {
         seedFirstPush: true,

package/dist/clients/lsp/server.js

@@ -19,6 +19,7 @@ import { resolveOpengrepConfig } from "../opengrep-config.js";
 import { resolveZizmorGitHubToken } from "../zizmor-config.js";
 import { logLatency } from "../latency-logger.js";
 import { findLocalSgconfig, resolveBaselineSgconfig } from "../sgconfig.js";
+import { resolveAstGrepNativeExe } from "./server-strategies.js";
 import { isCommandAvailableAsync, safeSpawnAsync } from "../safe-spawn.js";
 import { launchLSP } from "./launch.js";
 import { createLombokJdtlsArgs } from "./lombok.js";
@@ -1896,8 +1897,14 @@ export const AstGrepServer = {
             if (baseline)
                 args = ["lsp", "--config", baseline];
         }
+        // #472: prefer the platform-native exe directly (one less orphanable
+        // node-bin-wrapper layer). Prepended as the first candidate; falls back
+        // to the existing "ast-grep" PATH/global-bin resolution when the
+        // optional native package isn't installed for this platform/arch.
+        const nativeExe = resolveAstGrepNativeExe();
+        const candidates = nativeExe ? [nativeExe, "ast-grep"] : ["ast-grep"];
         return resolveAndLaunch({
-            candidates: ["ast-grep"],
+            candidates,
             args,
             cwd: root,
             managedToolId: "ast-grep",

package/dist/clients/review-graph/builder.js

@@ -584,10 +584,24 @@ function writePending(key) {
             console.error("[review-graph] cache dir creation failed:", mkdirErr.message);
             return;
         }
-        fs.writeFile(pending.cachePath, json, "utf-8", (writeErr) => {
+        // Write-to-temp + rename so the snapshot lands atomically: a reader
+        // (another process's blind load, or the tier-2 disk load in tests) must
+        // never see a created-but-partially-written file — that parses as
+        // corrupt and silently forces a full rebuild. rename() replaces the
+        // destination atomically on both POSIX and Windows (libuv uses
+        // MOVEFILE_REPLACE_EXISTING).
+        const tmpPath = `${pending.cachePath}.tmp-${process.pid}`;
+        fs.writeFile(tmpPath, json, "utf-8", (writeErr) => {
             if (writeErr) {
                 console.error("[review-graph] cache write failed:", writeErr.message);
+                return;
             }
+            fs.rename(tmpPath, pending.cachePath, (renameErr) => {
+                if (renameErr) {
+                    console.error("[review-graph] cache rename failed:", renameErr.message);
+                    fs.rm(tmpPath, { force: true }, () => { });
+                }
+            });
         });
     });
 }
@@ -603,7 +617,11 @@ function ensurePersistExitHook() {
         for (const [, pending] of _pendingPersist) {
             try {
                 fs.mkdirSync(pending.cacheDir, { recursive: true });
-                fs.writeFileSync(pending.cachePath, JSON.stringify(pending.data), "utf-8");
+                // Same atomic tmp+rename as writePending: even at teardown a crash
+                // mid-write must not leave a truncated snapshot for the next start.
+                const tmpPath = `${pending.cachePath}.tmp-${process.pid}`;
+                fs.writeFileSync(tmpPath, JSON.stringify(pending.data), "utf-8");
+                fs.renameSync(tmpPath, pending.cachePath);
             }
             catch {
                 // Teardown is best-effort; a missed persist just re-confirms next start.