fix: xlings 发现以 mcpp self env 为权威来源（项目级契约），路径探测仅作回退

Author: lildengzi

src/cliController.ts

@@ -630,7 +630,7 @@ export class McppCliController {
     return false;
   }
 
-  private mcppExecutable(project: McppProjectDiscovery | undefined): string {
+  public mcppExecutable(project: McppProjectDiscovery | undefined): string {
     const uri = project === undefined
       ? vscode.workspace.workspaceFolders?.[0]?.uri
       : vscode.Uri.file(project.root);

src/extension.ts

@@ -19,7 +19,7 @@ import {
   type McppProjectDiscovery,
 } from "./discovery";
 import {
-  findXlingsExecutable,
+  resolveXlingsExecutable,
   llvmToolsVersionSpec,
   xlingsInstallArgs,
 } from "./llvmTools";
@@ -763,7 +763,9 @@ async function autoConfigureModulesWizard(
           : { stage: "clangd", state: "failed", detail: "clangd 配置未完成。" };
       }
 
-      const xlingsPath = findXlingsExecutable();
+      const xlingsPath = await resolveXlingsExecutable(
+        cliController.mcppExecutable(currentContext.project),
+      );
       const compilerPath = currentContext.analysis.compilerPath;
       if (xlingsPath === undefined || compilerPath === undefined) {
         return {

src/llvmTools.ts

@@ -4,7 +4,11 @@ import path from "node:path";
 import process from "node:process";
 
 import type { ToolIdentity } from "./analysis";
-import { runProcess, type ProcessResult } from "./process";
+import {
+  runProcess,
+  type ProcessResult,
+  type ProcessRunner,
+} from "./process";
 
 export function llvmToolsVersionSpec(identity: ToolIdentity): string {
   return `${identity.major}.${identity.minor}.${identity.patch}`;
@@ -131,6 +135,26 @@ function xlingsResolvableOnPath(pathValue?: string): boolean {
   return false;
 }
 
+const XLINGS_BINARY_LINE = /^\s*xlings binary\s*=\s*(.+?)\s*$/im;
+
+// Source of truth is mcpp itself, not the filesystem or PATH: `mcpp self env`
+// reports the exact xlings bundled with THIS mcpp (mcpp is a project-level
+// environment; it owns its tool paths). Works for install.sh, AUR and any
+// custom MCPP_PREFIX layout. Falls back to the historical path heuristics for
+// standalone ~/.xlings installs and for mcpp versions without the line.
+export async function resolveXlingsExecutable(
+  mcppExecutable: string,
+  runner: ProcessRunner = runProcess,
+): Promise<string | undefined> {
+  const result = await runner(mcppExecutable, ["self", "env"]);
+  const match = `${result.stdout}\n${result.stderr}`.match(XLINGS_BINARY_LINE);
+  const reported = match?.[1]?.trim();
+  if (reported !== undefined && reported.length > 0 && existsSync(reported)) {
+    return reported;
+  }
+  return findXlingsExecutable();
+}
+
 export async function runXlingsCommand(
   xlingsPath: string,
   args: string[],

test/llvmTools.test.ts

@@ -10,6 +10,7 @@ import {
   xlingsInstallArgs,
   deriveInstalledClangdPath,
   findXlingsExecutable,
+  resolveXlingsExecutable,
 } from "../src/llvmTools";
 
 test("extracts version string from ToolIdentity", () => {
@@ -118,3 +119,41 @@ test("findXlingsExecutable honors MCPP_VENDORED_XLINGS", () => {
     rmSync(root, { recursive: true, force: true });
   }
 });
+
+test("resolveXlingsExecutable reads the xlings binary from `mcpp self env`", async () => {
+  const root = mkdtempSync(path.join(os.tmpdir(), "mcpp-vscode-selfenv-"));
+  const xlingsPath = path.join(root, "registry", "bin", "xlings");
+  mkdirSync(path.dirname(xlingsPath), { recursive: true });
+  writeFileSync(xlingsPath, "#!/bin/sh\n");
+  const runner = async () => ({
+    exitCode: 0,
+    stdout: `MCPP_HOME = ${root}\nxlings binary = ${xlingsPath}\nxlings pinned = 2026.8.8.1\n`,
+    stderr: "",
+  });
+  try {
+    assert.equal(
+      await resolveXlingsExecutable("/tools/mcpp", runner),
+      xlingsPath,
+    );
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("resolveXlingsExecutable falls back when the reported path does not exist", async () => {
+  const runner = async () => ({
+    exitCode: 0,
+    stdout: "xlings binary = /no/such/xlings\n",
+    stderr: "",
+  });
+  const result = await resolveXlingsExecutable("/tools/mcpp", runner);
+  // Fallback heuristics find nothing in this environment, so the result is
+  // undefined unless a standalone ~/.xlings or PATH xlings happens to exist.
+  assert.ok(result === undefined || typeof result === "string");
+});
+
+test("resolveXlingsExecutable falls back when `mcpp self env` fails", async () => {
+  const runner = async () => ({ exitCode: 1, stdout: "", stderr: "boom\n" });
+  const result = await resolveXlingsExecutable("/tools/mcpp", runner);
+  assert.ok(result === undefined || typeof result === "string");
+});