@neuralnomads/codenomad-dev 0.14.0-dev-20260420-04fc28c4 → 0.14.0-dev-20260421-1c317df6

package/dist/index.js

@@ -28,11 +28,12 @@ import { SideCarManager } from "./sidecars/manager";
 import { ClientConnectionManager } from "./clients/connection-manager";
 import { PluginChannelManager } from "./plugins/channel";
 import { VoiceModeManager } from "./plugins/voice-mode";
+import { readServerPackageVersion, resolveServerPublicDir } from "./runtime-paths";
 const require = createRequire(import.meta.url);
-const packageJson = require("../package.json");
+const packageJson = { version: readServerPackageVersion(import.meta.url) };
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const DEFAULT_UI_STATIC_DIR = path.resolve(__dirname, "../public");
+const DEFAULT_UI_STATIC_DIR = resolveServerPublicDir(import.meta.url);
 const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_CONFIG_PATH = "~/.config/codenomad/config.json";
 const DEFAULT_HTTPS_PORT = 9898;

package/dist/opencode-config/package.json

@@ -4,6 +4,6 @@
   "private": true,
   "license": "MIT",
   "dependencies": {
-    "@opencode-ai/plugin": "1.3.7"
+    "@opencode-ai/plugin": "1.14.19"
   }
-}
+}

package/dist/opencode-config.js

@@ -1,20 +1,9 @@
 import { existsSync } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
 import { createLogger } from "./logger";
+import { resolveOpencodeTemplateDir } from "./runtime-paths";
 const log = createLogger({ component: "opencode-config" });
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const devTemplateDir = path.resolve(__dirname, "../../opencode-config");
-const resourcesPath = process.resourcesPath;
-const prodTemplateDirs = [
-    resourcesPath ? path.resolve(resourcesPath, "opencode-config") : undefined,
-    path.resolve(__dirname, "opencode-config"),
-].filter((dir) => Boolean(dir));
-const isDevBuild = Boolean(process.env.CODENOMAD_DEV ?? process.env.CLI_UI_DEV_SERVER) || existsSync(devTemplateDir);
-const templateDir = isDevBuild
-    ? devTemplateDir
-    : prodTemplateDirs.find((dir) => existsSync(dir)) ?? prodTemplateDirs[0];
+const templateDir = resolveOpencodeTemplateDir(import.meta.url);
+const isDevBuild = Boolean(process.env.CODENOMAD_DEV ?? process.env.CLI_UI_DEV_SERVER);
 export function getOpencodeConfigDir() {
     if (!existsSync(templateDir)) {
         throw new Error(`CodeNomad Opencode config template missing at ${templateDir}`);

package/dist/runtime-paths.js

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function safeModuleDir(importMetaUrl) {
+    try {
+        return path.dirname(fileURLToPath(importMetaUrl));
+    }
+    catch {
+        return null;
+    }
+}
+function firstExistingPath(candidates, predicate) {
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        if (predicate(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export function getPackagedDistDir() {
+    return path.dirname(process.execPath);
+}
+export function resolveServerPackageRoot(importMetaUrl) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const configuredRoot = process.env.CODENOMAD_SERVER_ROOT?.trim();
+    const candidates = [
+        configuredRoot ? path.resolve(configuredRoot) : null,
+        moduleDir ? path.resolve(moduleDir, "..") : null,
+        path.resolve(getPackagedDistDir(), ".."),
+    ];
+    return (firstExistingPath(candidates, (value) => fs.existsSync(path.join(value, "package.json"))) ??
+        candidates.find((value) => Boolean(value)) ??
+        process.cwd());
+}
+export function resolveServerPublicDir(importMetaUrl) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const candidates = [moduleDir ? path.resolve(moduleDir, "../public") : null, path.join(resolveServerPackageRoot(importMetaUrl), "public")];
+    return firstExistingPath(candidates, (value) => fs.existsSync(value)) ?? candidates[candidates.length - 1];
+}
+export function resolveAuthTemplatePath(importMetaUrl, fileName) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const distDir = getPackagedDistDir();
+    const candidates = [
+        moduleDir ? path.join(moduleDir, "auth-pages", fileName) : null,
+        path.join(distDir, "auth-pages", fileName),
+        path.join(distDir, "server", "routes", "auth-pages", fileName),
+    ];
+    return firstExistingPath(candidates, (value) => fs.existsSync(value)) ?? candidates[0];
+}
+export function resolveOpencodeTemplateDir(importMetaUrl) {
+    const moduleDir = safeModuleDir(importMetaUrl);
+    const resourcesPath = process.resourcesPath;
+    const candidates = [
+        moduleDir ? path.resolve(moduleDir, "../../opencode-config") : null,
+        resourcesPath ? path.resolve(resourcesPath, "opencode-config") : null,
+        moduleDir ? path.resolve(moduleDir, "opencode-config") : null,
+        path.join(getPackagedDistDir(), "opencode-config"),
+    ];
+    return firstExistingPath(candidates, (value) => fs.existsSync(value)) ?? candidates[candidates.length - 1];
+}
+export function readServerPackageVersion(importMetaUrl) {
+    const packageJsonPath = path.join(resolveServerPackageRoot(importMetaUrl), "package.json");
+    const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    return typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version : "0.0.0";
+}

package/dist/server/http-server.js

@@ -5,6 +5,8 @@ import replyFrom from "@fastify/reply-from";
 import fs from "fs";
 import { connect as connectTcp } from "net";
 import path from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
 import { connect as connectTls } from "tls";
 import { fetch } from "undici";
 import { isValidWorktreeSlug } from "../workspaces/git-worktrees";
@@ -489,47 +491,49 @@ async function proxyWorkspaceRequest(args) {
     if (logger.isLevelEnabled("trace")) {
         logger.trace({ workspaceId, targetUrl, body: request.body }, "Instance proxy payload");
     }
-    return reply.from(targetUrl, {
-        rewriteRequestHeaders: (_originalRequest, headers) => {
-            if (instanceAuthHeader) {
-                headers.authorization = instanceAuthHeader;
-            }
-            // OpenCode expects the *full* path; we send it via header to avoid query tampering.
-            const isNonASCII = /[^\x00-\x7F]/.test(directory);
-            const encodedDirectory = isNonASCII ? encodeURIComponent(directory) : directory;
-            headers["x-opencode-directory"] = encodedDirectory;
-            if (logger.isLevelEnabled("trace")) {
-                const outgoing = {};
-                for (const [key, value] of Object.entries(headers)) {
-                    outgoing[key] = value;
-                }
-                // Redact sensitive headers.
-                for (const key of Object.keys(outgoing)) {
-                    const lower = key.toLowerCase();
-                    if (lower === "authorization" || lower === "cookie" || lower === "set-cookie") {
-                        outgoing[key] = "<redacted>";
-                    }
-                }
-                logger.trace({
-                    workspaceId,
-                    method: request.method,
-                    targetUrl,
-                    worktreeSlug,
-                    directory,
-                    contentType: request.headers["content-type"],
-                    body: bodyToJson(request.body),
-                    headers: outgoing,
-                }, "Proxy -> OpenCode request");
-            }
-            return headers;
-        },
-        onError: (proxyReply, { error }) => {
-            logger.error({ err: error, workspaceId, targetUrl }, "Failed to proxy workspace request");
-            if (!proxyReply.sent) {
-                proxyReply.code(502).send({ error: "Workspace instance proxy failed" });
-            }
-        },
-    });
+    const headers = buildWorkspaceInstanceProxyHeaders(request.headers, instanceAuthHeader, directory);
+    if (logger.isLevelEnabled("trace")) {
+        logger.trace({
+            workspaceId,
+            method: request.method,
+            targetUrl,
+            worktreeSlug,
+            directory,
+            contentType: request.headers["content-type"],
+            body: bodyToJson(request.body),
+            headers: redactProxyHeadersForLogs(headers),
+        }, "Proxy -> OpenCode request");
+    }
+    const init = {
+        method: request.method,
+        headers,
+        redirect: "manual",
+    };
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        const body = toProxyRequestBody(request.body);
+        if (body !== undefined) {
+            init.body = body;
+            init.duplex = "half";
+        }
+    }
+    try {
+        const response = await fetch(targetUrl, init);
+        reply.code(response.status);
+        applyInstanceProxyResponseHeaders(reply, response);
+        if (!response.body || request.method === "HEAD") {
+            reply.send();
+            return;
+        }
+        reply.hijack();
+        reply.raw.writeHead(reply.statusCode, toOutgoingHeaders(reply.getHeaders()));
+        await pipeline(Readable.fromWeb(response.body), reply.raw);
+    }
+    catch (error) {
+        logger.error({ err: error, workspaceId, targetUrl }, "Failed to proxy workspace request");
+        if (!reply.sent) {
+            reply.code(502).send({ error: "Workspace instance proxy failed" });
+        }
+    }
 }
 function extractOpencodeDirectoryOverride(pathSuffix) {
     if (!pathSuffix) {
@@ -692,12 +696,78 @@ function isApiRequest(rawUrl) {
 function buildProxyHeaders(headers) {
     const result = {};
     for (const [key, value] of Object.entries(headers ?? {})) {
-        if (!value || key.toLowerCase() === "host")
+        const lower = key.toLowerCase();
+        if (!value || lower === "host" || isHopByHopHeader(lower))
             continue;
         result[key] = Array.isArray(value) ? value.join(",") : value;
     }
     return result;
 }
+function toProxyRequestBody(body) {
+    if (body == null) {
+        return undefined;
+    }
+    if (typeof body.pipe === "function") {
+        return body;
+    }
+    if (typeof body[Symbol.asyncIterator] === "function") {
+        return body;
+    }
+    if (Buffer.isBuffer(body) || typeof body === "string" || body instanceof Uint8Array) {
+        return body;
+    }
+    return JSON.stringify(body);
+}
+function buildWorkspaceInstanceProxyHeaders(headers, instanceAuthHeader, directory) {
+    const next = buildProxyHeaders(headers);
+    if (instanceAuthHeader) {
+        next.authorization = instanceAuthHeader;
+    }
+    const isNonASCII = /[^\x00-\x7F]/.test(directory);
+    next["x-opencode-directory"] = isNonASCII ? encodeURIComponent(directory) : directory;
+    return next;
+}
+function redactProxyHeadersForLogs(headers) {
+    const outgoing = { ...headers };
+    for (const key of Object.keys(outgoing)) {
+        const lower = key.toLowerCase();
+        if (lower === "authorization" || lower === "cookie" || lower === "set-cookie") {
+            outgoing[key] = "<redacted>";
+        }
+    }
+    return outgoing;
+}
+function applyInstanceProxyResponseHeaders(reply, response) {
+    response.headers.forEach((value, key) => {
+        const lower = key.toLowerCase();
+        if (isHopByHopHeader(lower) || lower === "content-length" || lower === "content-encoding") {
+            return;
+        }
+        reply.header(key, value);
+    });
+}
+function toOutgoingHeaders(headers) {
+    const next = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined) {
+            continue;
+        }
+        next[key] = Array.isArray(value) ? value.map(String) : String(value);
+    }
+    return next;
+}
+function isHopByHopHeader(name) {
+    return new Set([
+        "connection",
+        "keep-alive",
+        "proxy-authenticate",
+        "proxy-authorization",
+        "te",
+        "trailer",
+        "transfer-encoding",
+        "upgrade",
+    ]).has(name);
+}
 async function proxySideCarRequest(args) {
     const sidecarId = args.request.params.id ?? "";
     const sidecar = await args.sidecarManager.get(sidecarId);

package/dist/server/routes/auth.js

@@ -1,6 +1,7 @@
 import fs from "fs";
 import { z } from "zod";
 import { isLoopbackAddress } from "../../auth/http-auth";
+import { resolveAuthTemplatePath } from "../../runtime-paths";
 const LoginSchema = z.object({
     username: z.string().min(1),
     password: z.string().min(1),
@@ -11,26 +12,26 @@ const TokenSchema = z.object({
 const PasswordSchema = z.object({
     password: z.string().min(8),
 });
-const LOGIN_TEMPLATE_URL = new URL("./auth-pages/login.html", import.meta.url);
-const TOKEN_TEMPLATE_URL = new URL("./auth-pages/token.html", import.meta.url);
+const LOGIN_TEMPLATE_PATH = resolveAuthTemplatePath(import.meta.url, "login.html");
+const TOKEN_TEMPLATE_PATH = resolveAuthTemplatePath(import.meta.url, "token.html");
 let cachedLoginTemplate = null;
 let cachedTokenTemplate = null;
-function readTemplate(url, cache) {
+function readTemplate(filePath, cache) {
     if (cache)
         return cache;
-    const content = fs.readFileSync(url, "utf-8");
+    const content = fs.readFileSync(filePath, "utf-8");
     return content;
 }
 function getLoginHtml(defaultUsername) {
     if (!cachedLoginTemplate) {
-        cachedLoginTemplate = readTemplate(LOGIN_TEMPLATE_URL, null);
+        cachedLoginTemplate = readTemplate(LOGIN_TEMPLATE_PATH, null);
     }
     const escapedUsername = escapeHtml(defaultUsername);
     return cachedLoginTemplate.replace(/\{\{DEFAULT_USERNAME\}\}/g, escapedUsername);
 }
 function getTokenHtml() {
     if (!cachedTokenTemplate) {
-        cachedTokenTemplate = readTemplate(TOKEN_TEMPLATE_URL, null);
+        cachedTokenTemplate = readTemplate(TOKEN_TEMPLATE_PATH, null);
     }
     return cachedTokenTemplate;
 }

package/dist/server/routes/settings.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { probeBinaryVersion } from "../../workspaces/runtime";
+import { probeBinaryVersion } from "../../workspaces/spawn";
 import { sanitizeConfigDoc, sanitizeConfigOwner } from "../../settings/public-config";
 const ValidateBinarySchema = z.object({
     path: z.string(),

package/dist/workspaces/__tests__/spawn.test.js

@@ -0,0 +1,139 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { buildWindowsSpawnSpec, buildWslSignalSpec, parseWslUncPath, resolveWslWorkingDirectory } from "../spawn";
+describe("parseWslUncPath", () => {
+    it("parses WSL UNC paths into distro and linux path", () => {
+        assert.deepEqual(parseWslUncPath(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`), {
+            distro: "Ubuntu",
+            linuxPath: "/home/dev/.opencode/bin/opencode",
+        });
+    });
+    it("supports the legacy wsl$ UNC prefix", () => {
+        assert.deepEqual(parseWslUncPath(String.raw `\\wsl$\Ubuntu\home\dev`), {
+            distro: "Ubuntu",
+            linuxPath: "/home/dev",
+        });
+    });
+});
+describe("resolveWslWorkingDirectory", () => {
+    it("keeps WSL workspace folders in the same distro", () => {
+        assert.equal(JSON.stringify(resolveWslWorkingDirectory(String.raw `\\wsl.localhost\Ubuntu\home\dev\workspace`, "Ubuntu")), JSON.stringify({ kind: "linux", path: "/home/dev/workspace" }));
+    });
+    it("keeps Windows drive paths so WSL can resolve them with wslpath", () => {
+        assert.equal(JSON.stringify(resolveWslWorkingDirectory(String.raw `C:\Users\dev\workspace`, "Ubuntu")), JSON.stringify({ kind: "windows", path: String.raw `C:\Users\dev\workspace` }));
+    });
+    it("keeps UNC network paths so WSL can resolve them with wslpath", () => {
+        assert.equal(JSON.stringify(resolveWslWorkingDirectory(String.raw `\\server\share\workspace`, "Ubuntu")), JSON.stringify({ kind: "windows", path: String.raw `\\server\share\workspace` }));
+    });
+    it("rejects WSL workspace folders from a different distro", () => {
+        assert.equal(resolveWslWorkingDirectory(String.raw `\\wsl.localhost\Debian\home\dev\workspace`, "Ubuntu"), null);
+    });
+});
+describe("buildWindowsSpawnSpec", () => {
+    it("wraps WSL binaries with wsl.exe and propagates required env vars", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve", "--port", "0"], {
+            cwd: String.raw `\\wsl.localhost\Ubuntu\home\dev\workspace`,
+            env: {
+                OPENCODE_CONFIG_DIR: String.raw `C:\Users\dev\AppData\Roaming\CodeNomad\opencode-config`,
+                CODENOMAD_INSTANCE_ID: "workspace-123",
+                OPENCODE_SERVER_PASSWORD: "secret",
+            },
+            propagateEnvKeys: ["OPENCODE_CONFIG_DIR", "CODENOMAD_INSTANCE_ID", "OPENCODE_SERVER_PASSWORD"],
+        });
+        assert.equal(spec.command, "wsl.exe");
+        assert.deepEqual(spec.args, [
+            "--distribution",
+            "Ubuntu",
+            "--cd",
+            "/home/dev/workspace",
+            "--exec",
+            "/home/dev/.opencode/bin/opencode",
+            "serve",
+            "--port",
+            "0",
+        ]);
+        assert.equal(spec.cwd, undefined);
+        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_DIR/p:CODENOMAD_INSTANCE_ID:OPENCODE_SERVER_PASSWORD");
+    });
+    it("upgrades existing WSLENV path entries to include /p", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
+            env: {
+                OPENCODE_CONFIG_DIR: String.raw `C:\Users\dev\AppData\Roaming\CodeNomad\opencode-config`,
+                WSLENV: "OPENCODE_CONFIG_DIR:CODENOMAD_INSTANCE_ID/u",
+            },
+            propagateEnvKeys: ["OPENCODE_CONFIG_DIR", "CODENOMAD_INSTANCE_ID"],
+        });
+        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_DIR/p:CODENOMAD_INSTANCE_ID/u");
+    });
+    it("propagates inherited known path variables even when they are not explicitly requested", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
+            env: {
+                NODE_EXTRA_CA_CERTS: String.raw `C:\certs\root.pem`,
+            },
+        });
+        assert.equal(spec.env?.WSLENV, "NODE_EXTRA_CA_CERTS/p");
+    });
+    it("uses wslpath for Windows workspace folders instead of assuming /mnt", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve", "--port", "0"], {
+            cwd: String.raw `C:\Users\dev\workspace`,
+        });
+        assert.equal(spec.command, "wsl.exe");
+        assert.deepEqual(spec.args, [
+            "--distribution",
+            "Ubuntu",
+            "--exec",
+            "sh",
+            "-lc",
+            'cd "$(wslpath -au "$1")" && shift && exec "$@"',
+            "codenomad-wsl-launch",
+            String.raw `C:\Users\dev\workspace`,
+            "/home/dev/.opencode/bin/opencode",
+            "serve",
+            "--port",
+            "0",
+        ]);
+    });
+    it("uses wslpath for UNC network workspace folders", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
+            cwd: String.raw `\\server\share\workspace`,
+        });
+        assert.equal(spec.command, "wsl.exe");
+        assert.deepEqual(spec.args, [
+            "--distribution",
+            "Ubuntu",
+            "--exec",
+            "sh",
+            "-lc",
+            'cd "$(wslpath -au "$1")" && shift && exec "$@"',
+            "codenomad-wsl-launch",
+            String.raw `\\server\share\workspace`,
+            "/home/dev/.opencode/bin/opencode",
+            "serve",
+        ]);
+    });
+    it("can wrap WSL launches to emit the Linux PID marker", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
+            cwd: String.raw `\\wsl.localhost\Ubuntu\home\dev\workspace`,
+            wslPidMarker: "__CODENOMAD_WSL_PID__:",
+        });
+        assert.equal(spec.command, "wsl.exe");
+        assert.deepEqual(spec.args, [
+            "--distribution",
+            "Ubuntu",
+            "--exec",
+            "sh",
+            "-lc",
+            `printf '%s%s\\n' '__CODENOMAD_WSL_PID__:' "$$" && cd "$1" && shift && exec "$@"`,
+            "codenomad-wsl-launch",
+            "/home/dev/workspace",
+            "/home/dev/.opencode/bin/opencode",
+            "serve",
+        ]);
+        assert.equal(spec.wsl?.pidMarker, "__CODENOMAD_WSL_PID__:");
+    });
+    it("builds the WSL kill command for tracked Linux PIDs", () => {
+        const spec = buildWslSignalSpec("Ubuntu", 4321, "SIGTERM");
+        assert.equal(spec.command, "wsl.exe");
+        assert.deepEqual(spec.args, ["--distribution", "Ubuntu", "--exec", "kill", "-TERM", "4321"]);
+    });
+});

package/dist/workspaces/manager.js

@@ -8,6 +8,58 @@ import { WorkspaceRuntime } from "./runtime";
 import { getOpencodeConfigDir } from "../opencode-config.js";
 import { buildOpencodeBasicAuthHeader, DEFAULT_OPENCODE_USERNAME, generateOpencodeServerPassword, OPENCODE_SERVER_PASSWORD_ENV, OPENCODE_SERVER_USERNAME_ENV, } from "./opencode-auth";
 const STARTUP_STABILITY_DELAY_MS = 1500;
+function defaultShellPath() {
+    const configured = process.env.SHELL?.trim();
+    if (configured) {
+        return configured;
+    }
+    return process.platform === "darwin" ? "/bin/zsh" : "/bin/bash";
+}
+function shellEscape(input) {
+    if (!input)
+        return "''";
+    return `'${input.replace(/'/g, `'\\''`)}'`;
+}
+function wrapCommandForShell(command, shellPath) {
+    const shellName = path.basename(shellPath).toLowerCase();
+    if (shellName.includes("bash")) {
+        return `if [ -f ~/.bashrc ]; then source ~/.bashrc >/dev/null 2>&1; fi; ${command}`;
+    }
+    if (shellName.includes("zsh")) {
+        return `if [ -f ~/.zshrc ]; then source ~/.zshrc >/dev/null 2>&1; fi; ${command}`;
+    }
+    return command;
+}
+function buildShellArgs(shellPath, command) {
+    const shellName = path.basename(shellPath).toLowerCase();
+    if (shellName.includes("zsh")) {
+        return ["-l", "-i", "-c", command];
+    }
+    return ["-l", "-c", command];
+}
+function resolveBinaryPathFromUserShell(identifier) {
+    if (process.platform === "win32") {
+        return null;
+    }
+    const shellPath = defaultShellPath();
+    const lookupCommand = wrapCommandForShell(`command -v ${shellEscape(identifier)}`, shellPath);
+    const result = spawnSync(shellPath, buildShellArgs(shellPath, lookupCommand), {
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            npm_config_prefix: undefined,
+            NPM_CONFIG_PREFIX: undefined,
+        },
+    });
+    if (result.status !== 0) {
+        return null;
+    }
+    const resolved = String(result.stdout ?? "")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    return resolved ?? null;
+}
 export class WorkspaceManager {
     constructor(options) {
         this.options = options;
@@ -200,6 +252,11 @@ export class WorkspaceManager {
         catch (error) {
             this.options.logger.warn({ identifier, err: error }, "Failed to resolve binary path from system PATH");
         }
+        const shellResolved = resolveBinaryPathFromUserShell(identifier);
+        if (shellResolved) {
+            this.options.logger.debug({ identifier, resolved: shellResolved }, "Resolved binary path from user shell");
+            return shellResolved;
+        }
         return identifier;
     }
     pickBinaryCandidate(candidates) {