jupyterlab_nb_venv_kernels_ui_extension 1.2.21 → 1.2.22

package/lib/index.js

@@ -131,16 +131,41 @@ async function fetchVenvEnvironments() {
         return null;
     }
 }
+/**
+ * Resolve an nb_venv_kernels environment path to an absolute path.
+ *
+ * nb_venv_kernels reports `env.path` relative to its `workspace_root` (e.g.
+ * `delaval/.../datascience/.venv`); the kernelspec `argv[0]` we compare it
+ * against is absolute. Join them so the prefix check works.
+ *
+ * @param envPath - The `path` field from an nb_venv_kernels environment
+ * @param workspaceRoot - The `workspace_root` field from the environments response
+ * @returns The absolute path, or null if it cannot be resolved
+ */
+function absoluteEnvPath(envPath, workspaceRoot) {
+    if (!envPath) {
+        return null;
+    }
+    if (envPath.startsWith('/')) {
+        return envPath.replace(/\/+$/, '');
+    }
+    if (!workspaceRoot || !workspaceRoot.startsWith('/')) {
+        return null;
+    }
+    return (workspaceRoot.replace(/\/+$/, '') + '/' + envPath.replace(/^\/+|\/+$/g, ''));
+}
 /**
  * Find a venv environment matching the given display name.
  *
- * When `executablePath` is provided, performs deterministic path-based
- * matching: the environment whose `path` is a prefix of the kernel's
- * Python executable wins. This avoids the substring-collision class of
- * bug where two envs share a name prefix (e.g. `demo` vs `demo-prod`).
+ * When `executablePath` is provided as an absolute path, performs
+ * deterministic path-based matching: the environment whose (resolved,
+ * absolute) `path` is a prefix of the kernel's Python executable wins. This
+ * avoids the substring-collision class of bug where two envs share a name
+ * prefix (e.g. `demo` vs `demo-prod`).
  *
- * Falls back to substring matching on env names only when no executable
- * path is available (e.g. KernelPathHandler returned null).
+ * Falls back to substring matching on env names when no executable path is
+ * available, or when none of the env paths could be resolved to absolute
+ * (old nb_venv_kernels without `workspace_root`).
  *
  * @param displayName - The kernel display name (used for fallback match)
  * @param executablePath - The kernel's `argv[0]` python path, if known
@@ -151,26 +176,31 @@ async function findVenvEnvironment(displayName, executablePath) {
     if (!envData) {
         return null;
     }
-    // Path-based match (preferred) - exact prefix on env.path eliminates
-    // ambiguity between envs with overlapping names. If we have an absolute
-    // executable path, we trust it: a non-match here is definitive (kernel
-    // not registered with nb_venv_kernels), so we do NOT fall back to
-    // substring matching - that would re-introduce the very collision bug
-    // this function is designed to prevent.
+    // Path-based match (preferred) - exact prefix on the env's absolute path
+    // eliminates ambiguity between envs with overlapping names. If we have an
+    // absolute executable path AND at least one env path resolved, we trust
+    // the result: a non-match is then definitive (kernel not registered with
+    // nb_venv_kernels), so we do NOT fall back to substring matching - that
+    // would re-introduce the very collision bug this function prevents.
     if (executablePath && executablePath.startsWith('/')) {
+        let attemptedPathMatch = false;
         for (const env of envData.environments) {
             if (env.type === 'conda') {
                 continue;
             }
-            if (!env.path) {
+            const envAbs = absoluteEnvPath(env.path, envData.workspace_root);
+            if (!envAbs) {
                 continue;
             }
-            const prefix = env.path.endsWith('/') ? env.path : env.path + '/';
-            if (executablePath.startsWith(prefix)) {
+            attemptedPathMatch = true;
+            if (executablePath.startsWith(envAbs + '/')) {
                 return env;
             }
         }
-        return null;
+        if (attemptedPathMatch) {
+            return null;
+        }
+        // No env path could be resolved to absolute - fall through to substring.
     }
     // Fallback: substring match on env names, used when executablePath is
     // missing or relative (e.g. nb_venv_kernels did not rewrite argv[0] for

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_nb_venv_kernels_ui_extension",
-    "version": "1.2.21",
+    "version": "1.2.22",
     "description": "Jupyterlab extension to allow user to right-click on the kernel launcher button and select 'Show in File Browser' or 'Open Terminal at location' menus and get them to navigate to location or open location in terminal respectively",
     "keywords": [
         "jupyter",

package/src/__tests__/jupyterlab_nb_venv_kernels_ui_extension.spec.ts

@@ -172,25 +172,48 @@ interface IVenvEnvironment {
   path: string;
 }
 
+function absoluteEnvPath(
+  envPath: string,
+  workspaceRoot: string | undefined
+): string | null {
+  if (!envPath) {
+    return null;
+  }
+  if (envPath.startsWith('/')) {
+    return envPath.replace(/\/+$/, '');
+  }
+  if (!workspaceRoot || !workspaceRoot.startsWith('/')) {
+    return null;
+  }
+  return (
+    workspaceRoot.replace(/\/+$/, '') + '/' + envPath.replace(/^\/+|\/+$/g, '')
+  );
+}
+
 function findVenvEnvironmentMatch(
   environments: IVenvEnvironment[],
   displayName: string,
-  executablePath?: string | null
+  executablePath?: string | null,
+  workspaceRoot?: string
 ): IVenvEnvironment | null {
   if (executablePath && executablePath.startsWith('/')) {
+    let attemptedPathMatch = false;
     for (const env of environments) {
       if (env.type === 'conda') {
         continue;
       }
-      if (!env.path) {
+      const envAbs = absoluteEnvPath(env.path, workspaceRoot);
+      if (!envAbs) {
         continue;
       }
-      const prefix = env.path.endsWith('/') ? env.path : env.path + '/';
-      if (executablePath.startsWith(prefix)) {
+      attemptedPathMatch = true;
+      if (executablePath.startsWith(envAbs + '/')) {
         return env;
       }
     }
-    return null;
+    if (attemptedPathMatch) {
+      return null;
+    }
   }
 
   const candidates = environments
@@ -338,6 +361,79 @@ describe('findVenvEnvironment matching', () => {
     );
     expect(match).toBeNull();
   });
+
+  // Regression: nb_venv_kernels reports env.path relative to workspace_root,
+  // but the kernelspec argv[0] (executablePath) is absolute. Earlier the
+  // prefix check compared an absolute path against a relative one and never
+  // matched - every uv kernel showed "is not managed by nb_venv_kernels".
+  it('matches when env.path is relative to workspace_root', () => {
+    const envs: IVenvEnvironment[] = [
+      {
+        name: 'cp-kpi',
+        custom_name: 'cp-kpi',
+        type: 'uv',
+        exists: true,
+        has_kernel: true,
+        path: 'delaval/cp/graph-engine/datascience/.venv'
+      }
+    ];
+    const match = findVenvEnvironmentMatch(
+      envs,
+      'Python [uv env:cp-kpi]',
+      '/home/lab/workspace/delaval/cp/graph-engine/datascience/.venv/bin/python',
+      '/home/lab/workspace'
+    );
+    expect(match?.name).toBe('cp-kpi');
+  });
+
+  it('disambiguates relative env paths sharing a prefix', () => {
+    const envs: IVenvEnvironment[] = [
+      {
+        name: 'demo',
+        custom_name: 'demo',
+        type: 'uv',
+        exists: true,
+        has_kernel: true,
+        path: 'projects/demo/.venv'
+      },
+      {
+        name: 'demo-prod',
+        custom_name: 'demo-prod',
+        type: 'uv',
+        exists: true,
+        has_kernel: true,
+        path: 'projects/demo-prod/.venv'
+      }
+    ];
+    const match = findVenvEnvironmentMatch(
+      envs,
+      'Python [uv env:demo-prod]',
+      '/home/lab/workspace/projects/demo-prod/.venv/bin/python',
+      '/home/lab/workspace'
+    );
+    expect(match?.name).toBe('demo-prod');
+  });
+
+  it('falls back to substring when env paths are relative and workspace_root is missing', () => {
+    const envs: IVenvEnvironment[] = [
+      {
+        name: 'cp-kpi',
+        custom_name: 'cp-kpi',
+        type: 'uv',
+        exists: true,
+        has_kernel: true,
+        path: 'delaval/cp/datascience/.venv'
+      }
+    ];
+    // old nb_venv_kernels: no workspace_root -> path-match can't be attempted
+    const match = findVenvEnvironmentMatch(
+      envs,
+      'Python [uv env:cp-kpi]',
+      '/home/lab/workspace/delaval/cp/datascience/.venv/bin/python',
+      undefined
+    );
+    expect(match?.name).toBe('cp-kpi');
+  });
 });
 
 describe('context menu configuration', () => {

package/src/index.ts

@@ -200,16 +200,47 @@ async function fetchVenvEnvironments(): Promise<IVenvEnvironmentsResponse | null
   }
 }
 
+/**
+ * Resolve an nb_venv_kernels environment path to an absolute path.
+ *
+ * nb_venv_kernels reports `env.path` relative to its `workspace_root` (e.g.
+ * `delaval/.../datascience/.venv`); the kernelspec `argv[0]` we compare it
+ * against is absolute. Join them so the prefix check works.
+ *
+ * @param envPath - The `path` field from an nb_venv_kernels environment
+ * @param workspaceRoot - The `workspace_root` field from the environments response
+ * @returns The absolute path, or null if it cannot be resolved
+ */
+function absoluteEnvPath(
+  envPath: string,
+  workspaceRoot: string | undefined
+): string | null {
+  if (!envPath) {
+    return null;
+  }
+  if (envPath.startsWith('/')) {
+    return envPath.replace(/\/+$/, '');
+  }
+  if (!workspaceRoot || !workspaceRoot.startsWith('/')) {
+    return null;
+  }
+  return (
+    workspaceRoot.replace(/\/+$/, '') + '/' + envPath.replace(/^\/+|\/+$/g, '')
+  );
+}
+
 /**
  * Find a venv environment matching the given display name.
  *
- * When `executablePath` is provided, performs deterministic path-based
- * matching: the environment whose `path` is a prefix of the kernel's
- * Python executable wins. This avoids the substring-collision class of
- * bug where two envs share a name prefix (e.g. `demo` vs `demo-prod`).
+ * When `executablePath` is provided as an absolute path, performs
+ * deterministic path-based matching: the environment whose (resolved,
+ * absolute) `path` is a prefix of the kernel's Python executable wins. This
+ * avoids the substring-collision class of bug where two envs share a name
+ * prefix (e.g. `demo` vs `demo-prod`).
  *
- * Falls back to substring matching on env names only when no executable
- * path is available (e.g. KernelPathHandler returned null).
+ * Falls back to substring matching on env names when no executable path is
+ * available, or when none of the env paths could be resolved to absolute
+ * (old nb_venv_kernels without `workspace_root`).
  *
  * @param displayName - The kernel display name (used for fallback match)
  * @param executablePath - The kernel's `argv[0]` python path, if known
@@ -224,26 +255,31 @@ async function findVenvEnvironment(
     return null;
   }
 
-  // Path-based match (preferred) - exact prefix on env.path eliminates
-  // ambiguity between envs with overlapping names. If we have an absolute
-  // executable path, we trust it: a non-match here is definitive (kernel
-  // not registered with nb_venv_kernels), so we do NOT fall back to
-  // substring matching - that would re-introduce the very collision bug
-  // this function is designed to prevent.
+  // Path-based match (preferred) - exact prefix on the env's absolute path
+  // eliminates ambiguity between envs with overlapping names. If we have an
+  // absolute executable path AND at least one env path resolved, we trust
+  // the result: a non-match is then definitive (kernel not registered with
+  // nb_venv_kernels), so we do NOT fall back to substring matching - that
+  // would re-introduce the very collision bug this function prevents.
   if (executablePath && executablePath.startsWith('/')) {
+    let attemptedPathMatch = false;
     for (const env of envData.environments) {
       if (env.type === 'conda') {
         continue;
       }
-      if (!env.path) {
+      const envAbs = absoluteEnvPath(env.path, envData.workspace_root);
+      if (!envAbs) {
         continue;
       }
-      const prefix = env.path.endsWith('/') ? env.path : env.path + '/';
-      if (executablePath.startsWith(prefix)) {
+      attemptedPathMatch = true;
+      if (executablePath.startsWith(envAbs + '/')) {
         return env;
       }
     }
-    return null;
+    if (attemptedPathMatch) {
+      return null;
+    }
+    // No env path could be resolved to absolute - fall through to substring.
   }
 
   // Fallback: substring match on env names, used when executablePath is