fix: narrow serial executor reentrancy detection and fix xlings PATH check

- createSerialExecutor: use AsyncLocalStorage-scoped flag instead of global
  depth counter so only same-async-context reentrant calls bypass the queue
- findXlingsExecutable: check PATH entries with existsSync before returning
  'xlings', so the wizard's 'install xlings' guidance branch is reachable
- add 2 tests: concurrent caller queues correctly, reentrant call bypasses

Author: wellwei

src/llvmTools.ts

@@ -79,8 +79,28 @@ export function findXlingsExecutable(): string | undefined {
     }
   }
 
-  // Fall back to PATH — execFile will resolve it
-  return "xlings";
+  // Fall back to PATH, but only when "xlings" actually resolves there. Always
+  // returning "xlings" hid the not-installed case, so callers could never show
+  // the "xlings 未安装" guidance.
+  return xlingsResolvableOnPath() ? "xlings" : undefined;
+}
+
+function xlingsResolvableOnPath(): boolean {
+  const names = process.platform === "win32"
+    ? ["xlings.exe", "xlings.cmd", "xlings.bat"]
+    : ["xlings"];
+  const pathValue = process.env.PATH ?? "";
+  for (const dir of pathValue.split(path.delimiter)) {
+    if (dir.length === 0) {
+      continue;
+    }
+    for (const name of names) {
+      if (existsSync(path.join(dir, name))) {
+        return true;
+      }
+    }
+  }
+  return false;
 }
 
 export async function runXlingsCommand(

src/workflow.ts

@@ -1,3 +1,5 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
 import type { CheckResult, ModuleCapability } from "./analysis";
 
 export type RefreshOutcomeLevel = "information" | "warning" | "error";
@@ -102,19 +104,30 @@ export function createKeyedSingleFlightReconciler<K, T>(
 
 export function createSerialExecutor(): <T>(operation: () => Promise<T>) => Promise<T> {
   let tail: Promise<void> = Promise.resolve();
-  let depth = 0;
+  // `running` is scoped to the async context of the in-flight operation via
+  // AsyncLocalStorage instead of a global counter, so only genuinely reentrant
+  // calls bypass the queue:
+  //   - a call made from inside an operation's own async chain (e.g.
+  //     wizard → build → reconcile → executor) sees `running` and executes
+  //     immediately — the outer operation is awaiting it, so queuing would hang;
+  //   - an unrelated concurrent caller (a separate command/event that has its
+  //     own async context) does not see it and queues behind the in-flight
+  //     operation, which the previous `depth > 0` check would wrongly let run
+  //     concurrently.
+  const state = { running: false };
+  const storage = new AsyncLocalStorage<{ running: boolean }>();
 
   return <T>(operation: () => Promise<T>): Promise<T> => {
-    if (depth > 0) {
+    if (storage.getStore() === state && state.running) {
       return operation();
     }
 
     const wrapped = async (): Promise<T> => {
-      depth += 1;
+      state.running = true;
       try {
-        return await operation();
+        return await storage.run(state, operation);
       } finally {
-        depth -= 1;
+        state.running = false;
       }
     };
 

test/workflow.test.ts

@@ -3,6 +3,7 @@ import test from "node:test";
 
 import * as workflow from "../src/workflow";
 import {
+  createSerialExecutor,
   createSingleFlightReconciler,
   describeRefreshOutcome,
   statusCommandForCapability,
@@ -132,6 +133,85 @@ test("serializes operations that share the workspace clangd configuration", asyn
   assert.deepEqual(calls, ["a:start", "a:end", "b:start", "b:end"]);
 });
 
+test("queues an unrelated concurrent caller behind an in-flight operation", async () => {
+  let releaseFirst: (() => void) | undefined;
+  const firstGate = new Promise<void>((resolve) => {
+    releaseFirst = resolve;
+  });
+  const calls: string[] = [];
+  let maxConcurrent = 0;
+  let active = 0;
+  const execute = createSerialExecutor();
+
+  const first = execute(async () => {
+    active += 1;
+    maxConcurrent = Math.max(maxConcurrent, active);
+    calls.push("a:start");
+    await firstGate;
+    calls.push("a:end");
+    active -= 1;
+    return "a";
+  });
+
+  // A second, unrelated invocation arrives while the first is still in flight,
+  // from a separate async context (a macrotask, like a user command event).
+  let second: Promise<string> | undefined;
+  const secondArrived = new Promise<void>((resolve) => {
+    setTimeout(() => {
+      second = execute(async () => {
+        active += 1;
+        maxConcurrent = Math.max(maxConcurrent, active);
+        calls.push("b:start");
+        calls.push("b:end");
+        active -= 1;
+        return "b";
+      });
+      resolve();
+    }, 10);
+  });
+  await secondArrived;
+
+  assert.deepEqual(calls, ["a:start"]);
+  assert.ok(releaseFirst);
+  releaseFirst();
+  assert.ok(second);
+  assert.deepEqual(await Promise.all([first, second]), ["a", "b"]);
+  assert.deepEqual(calls, ["a:start", "a:end", "b:start", "b:end"]);
+  assert.equal(maxConcurrent, 1);
+});
+
+test("runs a reentrant call from inside an operation without queuing", async () => {
+  const calls: string[] = [];
+  let releaseInner: (() => void) | undefined;
+  const innerGate = new Promise<void>((resolve) => {
+    releaseInner = resolve;
+  });
+  const execute = createSerialExecutor();
+
+  const outer = execute(async () => {
+    calls.push("outer:start");
+    await Promise.resolve();
+    const inner = execute(async () => {
+      calls.push("inner:start");
+      await innerGate;
+      calls.push("inner:end");
+      return "inner";
+    });
+    calls.push("outer:mid");
+    const value = await inner;
+    calls.push("outer:end");
+    return value;
+  });
+
+  // The outer operation's continuation (which makes the reentrant call) runs in
+  // the microtask queue, before the timer below fires.
+  await new Promise<void>((resolve) => setTimeout(resolve, 0));
+  assert.ok(releaseInner);
+  releaseInner();
+  assert.equal(await outer, "inner");
+  assert.deepEqual(calls, ["outer:start", "inner:start", "outer:mid", "inner:end", "outer:end"]);
+});
+
 test("retries a queued reconciliation after a transient failure", async () => {
   let releaseFirst: (() => void) | undefined;
   const firstGate = new Promise<void>((resolve) => {