vexp-cli 2.0.3 → 2.0.5

package/dist/agent-config.js

@@ -186,13 +186,13 @@ export function configureAgents(workspaceRoot, binaryPath, version, agentFilter,
         if (detector.mcpConfigFile) {
             const mcpConfigPath = path.join(workspaceRoot, detector.mcpConfigFile);
             const alwaysAllow = detector.agent === "Windsurf" ? VEXP_TOOLS : undefined;
-            if (writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath)) {
+            if (writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath, workspaceRoot)) {
                 mcpConfigs.push(detector.mcpConfigFile);
             }
         }
         // Claude Code: configure MCP in ~/.claude.json (user-scope, stdio)
         if (detector.agent === "Claude Code") {
-            const wrote = configureClaudeCodeGlobal(binaryPath, mcpServerPath);
+            const wrote = configureClaudeCodeGlobal(binaryPath, mcpServerPath, workspaceRoot);
             if (wrote)
                 mcpConfigs.push("~/.claude.json");
             // Install PreToolUse hook: blocks Grep/Glob when vexp daemon is available
@@ -216,14 +216,14 @@ export function configureAgents(workspaceRoot, binaryPath, version, agentFilter,
         // GitHub Copilot: VS Code format (.vscode/mcp.json with "servers" key)
         if (detector.agent === "GitHub Copilot") {
             const mcpPath = path.join(workspaceRoot, ".vscode/mcp.json");
-            if (writeVsCodeMcpConfig(mcpPath, binaryPath, mcpServerPath)) {
+            if (writeVsCodeMcpConfig(mcpPath, binaryPath, mcpServerPath, workspaceRoot)) {
                 mcpConfigs.push(".vscode/mcp.json");
             }
         }
         // Zed: context_servers in .zed/settings.json
         if (detector.agent === "Zed") {
             const zedPath = path.join(workspaceRoot, ".zed/settings.json");
-            if (writeZedMcpConfig(zedPath, binaryPath, mcpServerPath)) {
+            if (writeZedMcpConfig(zedPath, binaryPath, mcpServerPath, workspaceRoot)) {
                 mcpConfigs.push(".zed/settings.json");
             }
         }
@@ -306,11 +306,11 @@ export function configureSelectedAgents(workspaceRoot, binaryPath, version, sele
         if (detector.mcpConfigFile) {
             const mcpConfigPath = path.join(workspaceRoot, detector.mcpConfigFile);
             const alwaysAllow = detector.agent === "Windsurf" ? VEXP_TOOLS : undefined;
-            if (writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath))
+            if (writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath, workspaceRoot))
                 mcpConfigs.push(detector.mcpConfigFile);
         }
         if (detector.agent === "Claude Code") {
-            const wrote = configureClaudeCodeGlobal(binaryPath, mcpServerPath);
+            const wrote = configureClaudeCodeGlobal(binaryPath, mcpServerPath, workspaceRoot);
             if (wrote)
                 mcpConfigs.push("~/.claude.json");
             installClaudeCodeHook(workspaceRoot);
@@ -322,12 +322,12 @@ export function configureSelectedAgents(workspaceRoot, binaryPath, version, sele
         }
         if (detector.agent === "GitHub Copilot") {
             const mcpPath = path.join(workspaceRoot, ".vscode/mcp.json");
-            if (writeVsCodeMcpConfig(mcpPath, binaryPath, mcpServerPath))
+            if (writeVsCodeMcpConfig(mcpPath, binaryPath, mcpServerPath, workspaceRoot))
                 mcpConfigs.push(".vscode/mcp.json");
         }
         if (detector.agent === "Zed") {
             const zedPath = path.join(workspaceRoot, ".zed/settings.json");
-            if (writeZedMcpConfig(zedPath, binaryPath, mcpServerPath))
+            if (writeZedMcpConfig(zedPath, binaryPath, mcpServerPath, workspaceRoot))
                 mcpConfigs.push(".zed/settings.json");
         }
         results.push({ agent: detector.agent, configFile: detector.configFile, content, alreadyExists, action });
@@ -416,7 +416,7 @@ function mergeJsonConfig(filePath, mergePayload, version) {
  * Write MCP config JSON for agents that use mcpServers format (Cursor, Windsurf).
  * Returns true if a new entry was written.
  */
-function writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath) {
+function writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath, workspaceRoot) {
     let existing = {};
     if (fs.existsSync(mcpConfigPath)) {
         try {
@@ -430,11 +430,13 @@ function writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath) {
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     const targetCmd = useNode ? "node" : binaryPath;
     const targetArgs = useNode ? [mcpServerPath] : ["mcp"];
+    const targetEnv = workspaceRoot ? { VEXP_WORKSPACE: workspaceRoot } : undefined;
     if (servers && "vexp" in servers) {
         const cur = servers["vexp"];
         if (cur?.["command"] === targetCmd &&
             Array.isArray(cur?.["args"]) &&
-            JSON.stringify(cur["args"]) === JSON.stringify(targetArgs)) {
+            JSON.stringify(cur["args"]) === JSON.stringify(targetArgs) &&
+            JSON.stringify(cur["env"]) === JSON.stringify(targetEnv)) {
             return false; // Already up to date
         }
     }
@@ -443,6 +445,7 @@ function writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath) {
         vexp: {
             command: targetCmd,
             args: targetArgs,
+            ...(targetEnv ? { env: targetEnv } : {}),
             ...(alwaysAllow && alwaysAllow.length > 0 ? { alwaysAllow } : {}),
         },
     };
@@ -527,7 +530,7 @@ function configureCodexGlobal(binaryPath, mcpServerPath, workspaceRoot) {
  * Write .vscode/mcp.json for GitHub Copilot.
  * VS Code uses "servers" (not "mcpServers") + "type": "stdio".
  */
-function writeVsCodeMcpConfig(p, binaryPath, mcpServerPath) {
+function writeVsCodeMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
     let existing = {};
     if (fs.existsSync(p)) {
         try {
@@ -541,17 +544,24 @@ function writeVsCodeMcpConfig(p, binaryPath, mcpServerPath) {
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     const targetCmd = useNode ? "node" : binaryPath;
     const targetArgs = useNode ? [mcpServerPath] : ["mcp"];
+    const targetEnv = workspaceRoot ? { VEXP_WORKSPACE: workspaceRoot } : undefined;
     if (servers && "vexp" in servers) {
         const cur = servers["vexp"];
         if (cur?.["command"] === targetCmd &&
             Array.isArray(cur?.["args"]) &&
-            JSON.stringify(cur["args"]) === JSON.stringify(targetArgs)) {
+            JSON.stringify(cur["args"]) === JSON.stringify(targetArgs) &&
+            JSON.stringify(cur["env"]) === JSON.stringify(targetEnv)) {
             return false; // Already up to date
         }
     }
     existing.servers = {
         ...(servers ?? {}),
-        vexp: { type: "stdio", command: targetCmd, args: targetArgs },
+        vexp: {
+            type: "stdio",
+            command: targetCmd,
+            args: targetArgs,
+            ...(targetEnv ? { env: targetEnv } : {}),
+        },
     };
     fs.mkdirSync(path.dirname(p), { recursive: true });
     fs.writeFileSync(p, JSON.stringify(existing, null, 2), "utf-8");
@@ -560,7 +570,7 @@ function writeVsCodeMcpConfig(p, binaryPath, mcpServerPath) {
 /**
  * Write context_servers in .zed/settings.json for Zed.
  */
-function writeZedMcpConfig(p, binaryPath, mcpServerPath) {
+function writeZedMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
     let settings = {};
     if (fs.existsSync(p)) {
         try {
@@ -574,18 +584,26 @@ function writeZedMcpConfig(p, binaryPath, mcpServerPath) {
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     const targetCmd = useNode ? "node" : binaryPath;
     const targetArgs = useNode ? [mcpServerPath] : ["mcp"];
+    const targetEnv = workspaceRoot ? { VEXP_WORKSPACE: workspaceRoot } : undefined;
     if (cs && "vexp" in cs) {
         const cur = cs["vexp"];
         const curCmd = cur?.["command"];
         if (curCmd?.["path"] === targetCmd &&
             Array.isArray(curCmd?.["args"]) &&
-            JSON.stringify(curCmd["args"]) === JSON.stringify(targetArgs)) {
+            JSON.stringify(curCmd["args"]) === JSON.stringify(targetArgs) &&
+            JSON.stringify(curCmd["env"]) === JSON.stringify(targetEnv)) {
             return false; // Already up to date
         }
     }
     settings.context_servers = {
         ...(cs ?? {}),
-        vexp: { command: { path: targetCmd, args: targetArgs } },
+        vexp: {
+            command: {
+                path: targetCmd,
+                args: targetArgs,
+                ...(targetEnv ? { env: targetEnv } : {}),
+            },
+        },
     };
     // Pre-approve all vexp tools
     const agent = (settings.agent ?? {});
@@ -603,7 +621,7 @@ function writeZedMcpConfig(p, binaryPath, mcpServerPath) {
  * Configure vexp MCP in ~/.claude.json (user-scope) using the Rust binary.
  * Returns true if config was written/updated.
  */
-function configureClaudeCodeGlobal(binaryPath, mcpServerPath) {
+function configureClaudeCodeGlobal(binaryPath, mcpServerPath, workspaceRoot) {
     const home = os.homedir();
     if (!home)
         return false;
@@ -619,18 +637,23 @@ function configureClaudeCodeGlobal(binaryPath, mcpServerPath) {
     }
     const servers = config.mcpServers;
     const existing = servers?.["vexp"];
-    // Skip if already configured with this exact binary path
-    if (existing?.["command"] === binaryPath &&
+    const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
+    const desiredCommand = useNode ? "node" : binaryPath;
+    const desiredArgs = useNode ? [mcpServerPath] : ["mcp"];
+    const desiredEnv = workspaceRoot ? { VEXP_WORKSPACE: workspaceRoot } : undefined;
+    // Skip if already configured with identical command+args+env
+    if (existing?.["command"] === desiredCommand &&
         Array.isArray(existing?.["args"]) &&
-        existing["args"].includes("mcp")) {
+        JSON.stringify(existing["args"]) === JSON.stringify(desiredArgs) &&
+        JSON.stringify(existing["env"]) === JSON.stringify(desiredEnv)) {
         return false;
     }
-    const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     config.mcpServers = {
         ...(servers ?? {}),
         vexp: {
-            command: useNode ? "node" : binaryPath,
-            args: useNode ? [mcpServerPath] : ["mcp"],
+            command: desiredCommand,
+            args: desiredArgs,
+            ...(desiredEnv ? { env: desiredEnv } : {}),
         },
     };
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");

package/dist/binary.js

@@ -28,6 +28,120 @@ function gpuRequested() {
 export function preferGpuEnv() {
     return gpuRequested() ? { VEXP_PREFER_GPU: "1" } : {};
 }
+/**
+ * Build an env object that prepends the binary's directory to LD_LIBRARY_PATH
+ * (DYLD_* on macOS). Defensive fallback for binaries whose RPATH=$ORIGIN was
+ * not embedded at build time (older VSIX / npm packages).
+ */
+export function binaryEnv(binaryPath, extra = {}) {
+    const binaryDir = path.dirname(binaryPath);
+    const env = { ...process.env, ...extra };
+    if (process.platform === "linux") {
+        env.LD_LIBRARY_PATH = env.LD_LIBRARY_PATH ? `${binaryDir}:${env.LD_LIBRARY_PATH}` : binaryDir;
+    }
+    else if (process.platform === "darwin") {
+        env.DYLD_LIBRARY_PATH = env.DYLD_LIBRARY_PATH ? `${binaryDir}:${env.DYLD_LIBRARY_PATH}` : binaryDir;
+        env.DYLD_FALLBACK_LIBRARY_PATH = env.DYLD_FALLBACK_LIBRARY_PATH ? `${binaryDir}:${env.DYLD_FALLBACK_LIBRARY_PATH}` : binaryDir;
+    }
+    return env;
+}
+/**
+ * Local dev builds: `cargo build --release` drops unversioned `libggml.so`
+ * next to vexp-core, but the binary's DT_NEEDED references the soname
+ * `libggml.so.0` (+ `libllama.so.0`). Production packaging (CI) uses
+ * `cp -P` to copy the full symlink chain; dev builds don't. With RPATH=$ORIGIN,
+ * the loader needs the sonames next to the binary. Self-heal by creating
+ * the symlink chain on first CLI invocation.
+ */
+function ensureDevSonames(releaseDir) {
+    if (process.platform !== "linux" && process.platform !== "darwin")
+        return;
+    const ext = process.platform === "darwin" ? ".dylib" : ".so";
+    const names = ["libggml", "libggml-base", "libllama"];
+    for (const name of names) {
+        const soname = process.platform === "darwin"
+            ? `${name}.0${ext}` // libggml.0.dylib
+            : `${name}${ext}.0`; // libggml.so.0
+        const sonamePath = path.join(releaseDir, soname);
+        if (fs.existsSync(sonamePath) || isSymlink(sonamePath))
+            continue;
+        // Prefer the deepest-versioned file from the llama-cpp-sys build output.
+        const versioned = findVersionedLib(releaseDir, name, ext);
+        const unversioned = path.join(releaseDir, `${name}${ext}`);
+        try {
+            if (versioned) {
+                // Copy the versioned file (e.g. libggml.so.0.9.11) into releaseDir
+                // if not already there, then symlink soname → versioned.
+                const versionedName = path.basename(versioned);
+                const versionedDest = path.join(releaseDir, versionedName);
+                if (!fs.existsSync(versionedDest)) {
+                    fs.copyFileSync(versioned, versionedDest);
+                }
+                fs.symlinkSync(versionedName, sonamePath);
+            }
+            else if (fs.existsSync(unversioned)) {
+                // Fallback: symlink soname → unversioned .so
+                fs.symlinkSync(path.basename(unversioned), sonamePath);
+            }
+        }
+        catch {
+            // Non-fatal: user will get a clearer error from the binary itself.
+        }
+    }
+}
+function isSymlink(p) {
+    try {
+        return fs.lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/** Find the deepest-versioned matching lib in target/release/build/.../out/lib/. */
+function findVersionedLib(releaseDir, name, ext) {
+    const buildDir = path.join(releaseDir, "build");
+    if (!fs.existsSync(buildDir))
+        return null;
+    const pattern = process.platform === "darwin"
+        ? new RegExp(`^${escapeRe(name)}\\.(\\d+(?:\\.\\d+)*)${escapeRe(ext)}$`)
+        : new RegExp(`^${escapeRe(name)}${escapeRe(ext)}\\.(\\d+(?:\\.\\d+)*)$`);
+    const candidates = [];
+    try {
+        for (const entry of fs.readdirSync(buildDir)) {
+            if (!entry.startsWith("llama-cpp-sys-"))
+                continue;
+            const libDir = path.join(buildDir, entry, "out", "lib");
+            if (!fs.existsSync(libDir))
+                continue;
+            for (const f of fs.readdirSync(libDir)) {
+                const m = f.match(pattern);
+                if (m) {
+                    candidates.push({
+                        file: path.join(libDir, f),
+                        version: m[1].split(".").map((n) => parseInt(n, 10)),
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => {
+        for (let i = 0; i < Math.max(a.version.length, b.version.length); i++) {
+            const d = (b.version[i] ?? 0) - (a.version[i] ?? 0);
+            if (d !== 0)
+                return d;
+        }
+        return 0;
+    });
+    return candidates[0].file;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 export function getBinaryPath() {
     // Dev override: use VEXP_CORE_PATH env var to point to a local binary
     const envPath = process.env.VEXP_CORE_PATH;
@@ -39,6 +153,7 @@ export function getBinaryPath() {
     const scriptDir = path.dirname(new URL(import.meta.url).pathname);
     const monorepoRelease = path.resolve(scriptDir, "..", "..", "..", "target", "release", `vexp-core${ext}`);
     if (fs.existsSync(monorepoRelease)) {
+        ensureDevSonames(path.dirname(monorepoRelease));
         return monorepoRelease;
     }
     const key = `${process.platform}-${process.arch}`;
@@ -97,7 +212,7 @@ export async function getInstalledVersion() {
     try {
         const { execFile } = await import("child_process");
         return new Promise((resolve) => {
-            execFile(binaryPath, ["--version"], (err, stdout) => {
+            execFile(binaryPath, ["--version"], { env: binaryEnv(binaryPath) }, (err, stdout) => {
                 if (err) {
                     resolve(null);
                     return;