nebula-notebook 0.2.0 → 0.2.2

package/node-server/dist/discovery/discovery-service.js

@@ -41,10 +41,12 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pythonDiscovery = exports.PythonDiscoveryService = void 0;
 const fs = __importStar(require("fs"));
+const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
 const types_1 = require("./types");
+const conda_locations_1 = require("./conda-locations");
 const DEFAULT_CACHE_FILE = path.join(os.homedir(), '.nebula-notebook', 'python-cache.json');
 class PythonDiscoveryService {
     cache = {};
@@ -53,20 +55,31 @@ class PythonDiscoveryService {
     cacheTtlHours;
     versionCheckTimeoutMs;
     ipykernelCheckTimeoutMs;
-    condaListTimeoutMs;
     kernelInstallTimeoutMs;
     registrationTimeoutMs;
+    condaLocatorOverrides;
+    condaBinaryFinder;
     backgroundRefreshInProgress = false;
     constructor(options = {}) {
         this.cacheFile = options.cacheFile || DEFAULT_CACHE_FILE;
         this.cacheTtlHours = options.cacheTtlHours ?? types_1.DEFAULT_CACHE_TTL_HOURS;
         this.versionCheckTimeoutMs = options.versionCheckTimeoutMs ?? types_1.DEFAULT_VERSION_CHECK_TIMEOUT_MS;
         this.ipykernelCheckTimeoutMs = options.ipykernelCheckTimeoutMs ?? types_1.DEFAULT_IPYKERNEL_CHECK_TIMEOUT_MS;
-        this.condaListTimeoutMs = options.condaListTimeoutMs ?? types_1.DEFAULT_CONDA_LIST_TIMEOUT_MS;
         this.kernelInstallTimeoutMs = options.kernelInstallTimeoutMs ?? types_1.DEFAULT_KERNEL_INSTALL_TIMEOUT_MS;
         this.registrationTimeoutMs = options.registrationTimeoutMs ?? types_1.DEFAULT_REGISTRATION_TIMEOUT_MS;
+        this.condaLocatorOverrides = options.condaLocator ?? {};
+        this.condaBinaryFinder = options.condaBinaryFinder ?? conda_locations_1.findCondaLikeBinaries;
         this.loadCache();
     }
+    /** Context for the filesystem conda locator (test seam applied). */
+    condaContext() {
+        const ctx = (0, conda_locations_1.defaultCondaContext)();
+        if (this.condaLocatorOverrides.home)
+            ctx.home = this.condaLocatorOverrides.home;
+        if (this.condaLocatorOverrides.env)
+            ctx.env = this.condaLocatorOverrides.env;
+        return ctx;
+    }
     /**
      * Load cache from disk
      */
@@ -137,9 +150,11 @@ class PythonDiscoveryService {
         };
     }
     /**
-     * Run a command asynchronously with timeout
+     * Run a command asynchronously with timeout. `onData` receives every
+     * stdout/stderr chunk as it arrives (interleaved), for callers that
+     * surface live progress (the ipykernel install modal).
      */
-    runCommand(command, args, timeoutMs) {
+    runCommand(command, args, timeoutMs, onData) {
         return new Promise((resolve, reject) => {
             const child = (0, child_process_1.spawn)(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
             let stdout = '';
@@ -154,9 +169,11 @@ class PythonDiscoveryService {
             }, timeoutMs) : null;
             child.stdout?.on('data', (data) => {
                 stdout += data.toString();
+                onData?.(data.toString());
             });
             child.stderr?.on('data', (data) => {
                 stderr += data.toString();
+                onData?.(data.toString());
             });
             child.on('error', (err) => {
                 if (finished)
@@ -233,6 +250,21 @@ class PythonDiscoveryService {
     pythonExists(pythonPath) {
         return fs.existsSync(pythonPath);
     }
+    /**
+     * Async existence check. The discovery scan MUST use this (not existsSync):
+     * env dirs often live on network filesystems (GPFS) where each sync stat can
+     * take 10-500ms, and the scan runs dozens — enough to freeze the entire
+     * event loop for seconds (observed as "terminal dead during autosave").
+     */
+    async fsExists(p) {
+        try {
+            await fs_1.promises.access(p);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Get common conda base paths to search
      */
@@ -416,7 +448,13 @@ class PythonDiscoveryService {
         // Installable in place: not externally managed → use the env's own manager.
         if (!externallyManaged) {
             if (envType === 'conda') {
-                return `conda install -n ${envName || 'base'} ipykernel`;
+                // -p <prefix> works for named, base AND path-based (-p created) envs;
+                // -n would silently target the wrong env for the path-based ones.
+                const prefix = path.basename(path.dirname(pythonPath)) === 'bin'
+                    ? path.dirname(path.dirname(pythonPath))
+                    : path.dirname(pythonPath);
+                const p = prefix.includes(' ') ? `"${prefix}"` : prefix;
+                return `conda install -p ${p} ipykernel -y`;
             }
             if (envType === 'pixi') {
                 return `pixi add ipykernel`;
@@ -432,146 +470,95 @@ class PythonDiscoveryService {
         return `${py} -m venv ~/.venvs/nebula && ~/.venvs/nebula/bin/python -m pip install ipykernel`;
     }
     /**
-     * Find conda environments
+     * Public probe for kernel provisioning: does this interpreter have ipykernel,
+     * can we install into it, and if not — what should the user run instead?
+     * Uses the discovery cache for env-type context (better hints) but always
+     * probes the interpreter live, so a just-installed ipykernel is seen
+     * immediately even with a stale cache.
+     */
+    async probeForKernel(pythonPath) {
+        const { hasIpykernel, externallyManaged } = await this.probeEnvironment(pythonPath);
+        const cached = this.cache[pythonPath];
+        const installHint = this.buildInstallHint(pythonPath, cached?.envType ?? 'system', cached?.envName ?? null, hasIpykernel, externallyManaged);
+        return { hasIpykernel, externallyManaged, installHint };
+    }
+    /**
+     * Find conda environments — pure filesystem forensics (see conda-locations.ts).
+     * conda/mamba are never executed: envs come from ~/.conda/environments.txt,
+     * .condarc envs_dirs, well-known roots, the CONDA_ and MAMBA_ env vars, and
+     * roots derived from conda-like binaries found on PATH.
      */
     async findCondaEnvs() {
+        const ctx = this.condaContext();
         const envs = [];
         const seenPaths = new Set();
-        // Possible conda executable paths
-        const condaPaths = [
-            '/opt/anaconda3/bin/conda',
-            '/opt/miniconda3/bin/conda',
-            '/opt/homebrew/bin/conda',
-            '/opt/homebrew/anaconda3/bin/conda',
-            path.join(os.homedir(), 'anaconda3', 'bin', 'conda'),
-            path.join(os.homedir(), 'miniconda3', 'bin', 'conda'),
-            path.join(os.homedir(), 'miniforge3', 'bin', 'conda'),
-            path.join(os.homedir(), 'mambaforge', 'bin', 'conda'),
-            '/usr/local/anaconda3/bin/conda',
-            '/usr/local/miniconda3/bin/conda',
-        ];
-        // Try to get envs from conda command
-        for (const condaPath of condaPaths) {
-            if (!fs.existsSync(condaPath))
+        for (const loc of await (0, conda_locations_1.collectCondaEnvs)(ctx)) {
+            const pythonPath = (0, conda_locations_1.pythonExeForPrefix)(loc.prefix, ctx.platform);
+            if (seenPaths.has(pythonPath))
                 continue;
-            try {
-                const { stdout } = await this.runCommand(condaPath, ['env', 'list', '--json'], this.condaListTimeoutMs);
-                const data = JSON.parse(stdout);
-                for (const envPath of data.envs || []) {
-                    const pythonPath = path.join(envPath, 'bin', 'python');
-                    if (fs.existsSync(pythonPath) && !seenPaths.has(pythonPath)) {
-                        seenPaths.add(pythonPath);
-                        const envName = path.basename(envPath);
-                        const isBase = envPath === data.root_prefix || !envPath.includes('envs');
-                        envs.push({
-                            path: pythonPath,
-                            envType: 'conda',
-                            envName: isBase ? 'base' : envName,
-                            base: envPath,
-                        });
-                    }
-                }
-            }
-            catch (e) {
-                console.warn(`Error running conda env list: ${e}`);
-            }
-        }
-        // Also scan common conda base directories
-        for (const base of this.getCondaBasePaths()) {
-            if (!fs.existsSync(base))
+            // An env can legitimately lack python (e.g. `conda create` without it) —
+            // nothing to offer as a kernel, skip.
+            if (!(await this.fsExists(pythonPath)))
                 continue;
-            // Base environment
-            const basePython = path.join(base, 'bin', 'python');
-            if (fs.existsSync(basePython) && !seenPaths.has(basePython)) {
-                seenPaths.add(basePython);
-                envs.push({
-                    path: basePython,
-                    envType: 'conda',
-                    envName: 'base',
-                    base,
-                });
-            }
-            // Sub-environments
-            const envsDir = path.join(base, 'envs');
-            if (fs.existsSync(envsDir)) {
-                try {
-                    for (const envDir of fs.readdirSync(envsDir)) {
-                        const envPath = path.join(envsDir, envDir);
-                        if (!fs.statSync(envPath).isDirectory())
-                            continue;
-                        const pythonPath = path.join(envPath, 'bin', 'python');
-                        if (fs.existsSync(pythonPath) && !seenPaths.has(pythonPath)) {
-                            seenPaths.add(pythonPath);
-                            envs.push({
-                                path: pythonPath,
-                                envType: 'conda',
-                                envName: envDir,
-                                base,
-                            });
-                        }
-                    }
-                }
-                catch (e) {
-                    console.warn(`Error scanning conda envs: ${e}`);
-                }
-            }
+            seenPaths.add(pythonPath);
+            envs.push({
+                path: pythonPath,
+                envType: 'conda',
+                envName: loc.envName,
+                base: loc.base ?? loc.prefix,
+            });
         }
         return envs;
     }
     /**
      * Find pyenv Python versions
      */
-    findPyenvVersions() {
+    async findPyenvVersions() {
         const envs = [];
         const pyenvRoot = this.getPyenvVersionsPath();
-        if (!fs.existsSync(pyenvRoot)) {
-            return envs;
-        }
         try {
-            for (const versionDir of fs.readdirSync(pyenvRoot)) {
-                const versionPath = path.join(pyenvRoot, versionDir);
-                if (!fs.statSync(versionPath).isDirectory())
+            const entries = await fs_1.promises.readdir(pyenvRoot, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory() && !entry.isSymbolicLink())
                     continue;
-                const pythonPath = path.join(versionPath, 'bin', 'python');
-                if (fs.existsSync(pythonPath)) {
+                const pythonPath = path.join(pyenvRoot, entry.name, 'bin', 'python');
+                if (await this.fsExists(pythonPath)) {
                     envs.push({
                         path: pythonPath,
                         envType: 'pyenv',
-                        envName: versionDir,
+                        envName: entry.name,
                     });
                 }
             }
         }
-        catch (e) {
-            console.warn(`Error scanning pyenv versions: ${e}`);
+        catch {
+            // pyenv root missing/unreadable — nothing to scan
         }
         return envs;
     }
     /**
      * Find virtualenvs in common locations
      */
-    findVirtualenvs() {
+    async findVirtualenvs() {
         const envs = [];
         for (const venvDir of this.getVirtualenvPaths()) {
-            if (!fs.existsSync(venvDir))
-                continue;
             try {
-                for (const envName of fs.readdirSync(venvDir)) {
-                    const envPath = path.join(venvDir, envName);
-                    if (!fs.statSync(envPath).isDirectory())
+                const entries = await fs_1.promises.readdir(venvDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory() && !entry.isSymbolicLink())
                         continue;
-                    const pythonPath = path.join(envPath, 'bin', 'python');
-                    if (fs.existsSync(pythonPath)) {
+                    const pythonPath = path.join(venvDir, entry.name, 'bin', 'python');
+                    if (await this.fsExists(pythonPath)) {
                         envs.push({
                             path: pythonPath,
                             envType: 'venv',
-                            envName,
+                            envName: entry.name,
                         });
                     }
                 }
             }
-            catch (e) {
-                console.warn(`Error scanning virtualenvs: ${e}`);
+            catch {
+                // venv dir missing/unreadable — nothing to scan
             }
         }
         return envs;
@@ -579,22 +566,21 @@ class PythonDiscoveryService {
     /**
      * Find system Python installations
      */
-    findSystemPythons() {
+    async findSystemPythons() {
         const envs = [];
         const seen = new Set();
         for (const pythonPath of this.getSystemPythonPaths()) {
-            if (!fs.existsSync(pythonPath))
-                continue;
-            // Resolve symlinks to avoid duplicates
+            // Resolve symlinks to avoid duplicates (also serves as the existence check)
+            let realPath;
             try {
-                const realPath = fs.realpathSync(pythonPath);
-                if (seen.has(realPath))
-                    continue;
-                seen.add(realPath);
+                realPath = await fs_1.promises.realpath(pythonPath);
             }
             catch {
                 continue;
             }
+            if (seen.has(realPath))
+                continue;
+            seen.add(realPath);
             const envType = pythonPath.toLowerCase().includes('homebrew') ||
                 pythonPath.includes('/opt/homebrew') ? 'homebrew' : 'system';
             envs.push({
@@ -618,7 +604,7 @@ class PythonDiscoveryService {
         // can't distinguish; resolve symlinks first (e.g. ~/.local/bin/python3 → uv).
         let realPath = candidate.path;
         try {
-            realPath = fs.realpathSync(candidate.path);
+            realPath = await fs_1.promises.realpath(candidate.path);
         }
         catch { /* keep original */ }
         const envType = this.classifyEnvType(candidate.path, realPath, candidate.envType, isVenv);
@@ -644,9 +630,9 @@ class PythonDiscoveryService {
         // Collect all candidates
         const candidates = [];
         candidates.push(...(await this.findCondaEnvs()));
-        candidates.push(...this.findPyenvVersions());
-        candidates.push(...this.findVirtualenvs());
-        candidates.push(...this.findSystemPythons());
+        candidates.push(...(await this.findPyenvVersions()));
+        candidates.push(...(await this.findVirtualenvs()));
+        candidates.push(...(await this.findSystemPythons()));
         // Enrich in parallel
         const enrichPromises = candidates.map(c => this.enrichEnvironment(c));
         const results = await Promise.all(enrichPromises);
@@ -732,7 +718,7 @@ class PythonDiscoveryService {
      *     register-only path.
      */
     async installKernel(pythonPath, kernelName) {
-        if (!fs.existsSync(pythonPath)) {
+        if (!(await this.fsExists(pythonPath))) {
             throw new types_1.KernelProvisionError(`Python not found: ${pythonPath}`, 'python_not_found');
         }
         const { hasIpykernel, externallyManaged } = await this.probeEnvironment(pythonPath);
@@ -744,12 +730,11 @@ class PythonDiscoveryService {
                     `so Nebula can't install it here. Set up ipykernel in an isolated environment, then Register it.`, 'externally_managed', hint || undefined);
             }
             // Writable env without ipykernel: install it (safe — not externally managed).
+            // Async spawn (NOT execSync): a pip install can run 30s+, and execSync
+            // would freeze the whole server for that long.
             console.log(`Installing ipykernel for ${pythonPath}...`);
             try {
-                (0, child_process_1.execSync)(`"${pythonPath}" -m pip install ipykernel -q`, {
-                    timeout: this.kernelInstallTimeoutMs,
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                });
+                await this.runCommand(pythonPath, ['-m', 'pip', 'install', 'ipykernel', '-q'], this.kernelInstallTimeoutMs);
             }
             catch (e) {
                 const detail = this.errorOutput(e);
@@ -766,13 +751,10 @@ class PythonDiscoveryService {
             const version = await this.getPythonVersion(pythonPath) || '3';
             kernelName = this.generateKernelName(pythonPath, version);
         }
-        // Register kernel
+        // Register kernel (async spawn — see pip install above)
         console.log(`Registering kernel as ${kernelName}...`);
         try {
-            (0, child_process_1.execSync)(`"${pythonPath}" -m ipykernel install --user --name "${kernelName}"`, {
-                timeout: this.registrationTimeoutMs,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
+            await this.runCommand(pythonPath, ['-m', 'ipykernel', 'install', '--user', '--name', kernelName], this.registrationTimeoutMs);
         }
         catch (e) {
             throw new types_1.KernelProvisionError(`Failed to register kernel: ${this.errorOutput(e) || e}`, 'register_failed');
@@ -789,6 +771,108 @@ class PythonDiscoveryService {
             message: `Successfully registered kernel '${kernelName}'`,
         };
     }
+    /**
+     * Probe a manually-entered interpreter path, classify it (conda-meta →
+     * conda, pyvenv.cfg → venv, else system + the usual uv/pixi refinement),
+     * and persist it into the discovery cache so it shows up in the picker from
+     * now on. VSCode's "Enter interpreter path…" equivalent.
+     */
+    async probeAndRemember(pythonPath) {
+        if (!(await this.fsExists(pythonPath))) {
+            throw new types_1.KernelProvisionError(`Python not found: ${pythonPath}`, 'python_not_found');
+        }
+        const prefix = (0, conda_locations_1.prefixForPythonExe)(pythonPath);
+        let envType = 'system';
+        let envName = null;
+        if (await (0, conda_locations_1.isCondaEnv)(prefix)) {
+            envType = 'conda';
+            envName = path.basename(prefix);
+        }
+        else if (await this.fsExists(path.join(prefix, 'pyvenv.cfg'))) {
+            envType = 'venv';
+            envName = path.basename(prefix);
+        }
+        const env = await this.enrichEnvironment({ path: pythonPath, envType, envName });
+        if (!env) {
+            throw new types_1.KernelProvisionError(`${pythonPath} did not respond to --version — not a working Python interpreter`, 'python_not_found');
+        }
+        this.cache[pythonPath] = env;
+        this.saveToCache(this.cache);
+        return env;
+    }
+    /**
+     * Pick ONE installer for ipykernel, up front (VSCode's shape — no fallback
+     * chain at run time, so failures are attributable and honest):
+     *   1. conda env → a conda-like binary (conda/mamba/micromamba; PATH first,
+     *      then known roots) with `-p <prefix>` — correct for named, base and
+     *      path-based envs alike.
+     *   2. uv on PATH → `uv pip install --python <exe>` — works on ANY env,
+     *      including conda envs without a conda binary and envs without pip.
+     *   3. the env's own pip.
+     */
+    async planIpykernelInstall(pythonPath) {
+        const ctx = this.condaContext();
+        const prefix = (0, conda_locations_1.prefixForPythonExe)(pythonPath);
+        if (await (0, conda_locations_1.isCondaEnv)(prefix)) {
+            const bins = await this.condaBinaryFinder(ctx);
+            if (bins.length > 0) {
+                return { kind: 'conda', argv: [bins[0], 'install', '-p', prefix, 'ipykernel', '-y'] };
+            }
+        }
+        const uv = await (0, conda_locations_1.findExecutableOnPath)('uv', ctx);
+        if (uv) {
+            return { kind: 'uv', argv: [uv, 'pip', 'install', '--python', pythonPath, 'ipykernel'] };
+        }
+        return { kind: 'pip', argv: [pythonPath, '-m', 'pip', 'install', 'ipykernel'] };
+    }
+    /**
+     * Install ipykernel into an environment with the planned installer, then
+     * VERIFY it actually became importable. Refuses PEP 668 externally-managed
+     * interpreters up front (with guidance). Failure carries the installer's
+     * output — no silent fallback to a different installer.
+     */
+    async installIpykernel(pythonPath, onOutput) {
+        if (!(await this.fsExists(pythonPath))) {
+            throw new types_1.KernelProvisionError(`Python not found: ${pythonPath}`, 'python_not_found');
+        }
+        const before = await this.probeEnvironment(pythonPath);
+        if (before.hasIpykernel) {
+            return { installer: 'none', message: 'ipykernel is already installed' };
+        }
+        const cached = this.cache[pythonPath];
+        const hint = this.buildInstallHint(pythonPath, cached?.envType ?? 'system', cached?.envName ?? null, false, before.externallyManaged);
+        if (before.externallyManaged) {
+            throw new types_1.KernelProvisionError(`This Python is externally managed (PEP 668) — Nebula won't install into it. ` +
+                `Set up ipykernel in an isolated environment instead.`, 'externally_managed', hint || undefined);
+        }
+        const plan = await this.planIpykernelInstall(pythonPath);
+        console.log(`Installing ipykernel via ${plan.kind}: ${plan.argv.join(' ')}`);
+        // Echo the exact command first so the user sees WHAT ran, then live output.
+        onOutput?.(`$ ${plan.argv.join(' ')}\n`);
+        try {
+            await this.runCommand(plan.argv[0], plan.argv.slice(1), this.kernelInstallTimeoutMs, onOutput);
+        }
+        catch (e) {
+            const detail = this.errorOutput(e);
+            if (this.isExternallyManagedError(detail)) {
+                throw new types_1.KernelProvisionError('This Python blocks package installation (PEP 668). Set up ipykernel in an isolated environment instead.', 'externally_managed', hint || undefined);
+            }
+            // Honest failure: name the installer and surface the tail of its output.
+            const tail = detail.trim().split('\n').slice(-8).join('\n').slice(-600);
+            throw new types_1.KernelProvisionError(`${plan.kind} failed to install ipykernel${tail ? `:\n${tail}` : ''}`, 'install_failed', hint || undefined);
+        }
+        const after = await this.probeEnvironment(pythonPath);
+        if (!after.hasIpykernel) {
+            throw new types_1.KernelProvisionError(`${plan.kind} reported success but ipykernel is still not importable in ${pythonPath}`, 'install_failed', hint || undefined);
+        }
+        // Reflect reality in the cache so the picker updates without a rescan.
+        if (this.cache[pythonPath]) {
+            this.cache[pythonPath].hasIpykernel = true;
+            this.cache[pythonPath].installHint = null;
+            this.saveToCache(this.cache);
+        }
+        return { installer: plan.kind, message: `Installed ipykernel via ${plan.kind}` };
+    }
     /** Extract combined stdout+stderr text from a child_process error. */
     errorOutput(e) {
         const err = e;

package/node-server/dist/discovery/types.d.ts

@@ -43,6 +43,5 @@ export interface CacheInfo {
 export declare const DEFAULT_CACHE_TTL_HOURS = 24;
 export declare const DEFAULT_VERSION_CHECK_TIMEOUT_MS = 5000;
 export declare const DEFAULT_IPYKERNEL_CHECK_TIMEOUT_MS = 10000;
-export declare const DEFAULT_CONDA_LIST_TIMEOUT_MS = 30000;
 export declare const DEFAULT_KERNEL_INSTALL_TIMEOUT_MS = 120000;
 export declare const DEFAULT_REGISTRATION_TIMEOUT_MS = 60000;

package/node-server/dist/discovery/types.js

@@ -3,7 +3,7 @@
  * Python Discovery Service Types
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_REGISTRATION_TIMEOUT_MS = exports.DEFAULT_KERNEL_INSTALL_TIMEOUT_MS = exports.DEFAULT_CONDA_LIST_TIMEOUT_MS = exports.DEFAULT_IPYKERNEL_CHECK_TIMEOUT_MS = exports.DEFAULT_VERSION_CHECK_TIMEOUT_MS = exports.DEFAULT_CACHE_TTL_HOURS = exports.KernelProvisionError = void 0;
+exports.DEFAULT_REGISTRATION_TIMEOUT_MS = exports.DEFAULT_KERNEL_INSTALL_TIMEOUT_MS = exports.DEFAULT_IPYKERNEL_CHECK_TIMEOUT_MS = exports.DEFAULT_VERSION_CHECK_TIMEOUT_MS = exports.DEFAULT_CACHE_TTL_HOURS = exports.KernelProvisionError = void 0;
 class KernelProvisionError extends Error {
     code;
     installHint;
@@ -19,6 +19,5 @@ exports.KernelProvisionError = KernelProvisionError;
 exports.DEFAULT_CACHE_TTL_HOURS = 24;
 exports.DEFAULT_VERSION_CHECK_TIMEOUT_MS = 5000;
 exports.DEFAULT_IPYKERNEL_CHECK_TIMEOUT_MS = 10000;
-exports.DEFAULT_CONDA_LIST_TIMEOUT_MS = 30000;
 exports.DEFAULT_KERNEL_INSTALL_TIMEOUT_MS = 120000;
 exports.DEFAULT_REGISTRATION_TIMEOUT_MS = 60000;

package/node-server/dist/environment.d.ts

@@ -0,0 +1,12 @@
+export type EnvironmentKind = 'local' | 'cluster' | 'server';
+export interface EnvironmentInfo {
+    kind: EnvironmentKind;
+    /** 'high' = trust it; 'ambiguous' = the UI should ask the user once. */
+    confidence: 'high' | 'ambiguous';
+    /** Human-readable one-liner for the settings UI ("SLURM detected", …). */
+    reason: string;
+    hostname: string;
+    platform: NodeJS.Platform;
+    scheduler: string | null;
+}
+export declare function getEnvironment(): EnvironmentInfo;

package/node-server/dist/environment.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironment = getEnvironment;
+/**
+ * Environment awareness — where is this Nebula server running relative to the user?
+ *
+ * The "run the agent / autocomplete on this server vs. my machine" choice only
+ * makes sense when the server ISN'T the user's own machine. This detects the
+ * server's context so the UI can collapse that choice when it's meaningless
+ * (a local install) and surface it when it matters (a cluster/remote server).
+ *
+ *   kind = 'cluster'  → a scheduler (SLURM) is present: shared HPC login/compute node
+ *   kind = 'local'    → a personal machine (desktop OS / desktop session)
+ *   kind = 'server'   → some other remote host (headless, reached over ssh)
+ *
+ * Signals, most→least decisive:
+ *   NEBULA_ENV override → whatever it says (confidence: high)
+ *   scheduler present   → cluster                (high)
+ *   darwin              → local                  (high)
+ *   started inside ssh  → server                 (high — the user reaches this box remotely)
+ *   desktop session     → local                  (high — DISPLAY/Wayland ⇒ someone sits here)
+ *   headless linux, none of the above → local (safe default) but confidence:
+ *   'ambiguous' — the UI asks the user ONCE and stores their answer.
+ *
+ * Override with NEBULA_ENV=local|cluster|server, or per-user in the client
+ * settings (environmentOverride) — the client override always wins in the UI.
+ */
+const os = __importStar(require("os"));
+const allocation_service_1 = require("./scheduler/allocation-service");
+function detect(scheduler, platform) {
+    const override = (process.env.NEBULA_ENV || '').toLowerCase();
+    if (override === 'local' || override === 'cluster' || override === 'server') {
+        return { kind: override, confidence: 'high', reason: `NEBULA_ENV=${override}` };
+    }
+    if (scheduler) {
+        return { kind: 'cluster', confidence: 'high', reason: `${scheduler} scheduler detected` };
+    }
+    if (platform === 'darwin') {
+        return { kind: 'local', confidence: 'high', reason: 'macOS — a personal machine' };
+    }
+    // Started from inside an ssh session → the user reaches this box remotely.
+    if (process.env.SSH_CONNECTION || process.env.SSH_TTY || process.env.SSH_CLIENT) {
+        return { kind: 'server', confidence: 'high', reason: 'server was started over SSH' };
+    }
+    // A desktop session on Linux → someone sits at this machine.
+    if (process.env.DISPLAY || process.env.WAYLAND_DISPLAY || process.env.XDG_SESSION_TYPE === 'x11' || process.env.XDG_SESSION_TYPE === 'wayland') {
+        return { kind: 'local', confidence: 'high', reason: 'Linux desktop session detected' };
+    }
+    // Headless Linux, no scheduler, not launched over ssh (e.g. systemd unit,
+    // container, tmux that outlived its ssh). Could be a workstation or a remote
+    // box — default local (never nag a single-user install) but flag it so the
+    // UI can ask the user once instead of silently guessing.
+    return {
+        kind: 'local',
+        confidence: 'ambiguous',
+        reason: 'headless Linux with no scheduler — could be your workstation or a remote box',
+    };
+}
+function getEnvironment() {
+    // NO caching: scheduler detection completes asynchronously after boot, and
+    // the first /api/health frequently arrives before it (startup health polls,
+    // the browser tab reconnecting) — caching that first answer froze
+    // kind='local' onto SLURM login nodes for the server's whole lifetime.
+    // Recomputing is two method calls + os lookups; the answer self-corrects
+    // the moment scheduler detection lands.
+    const scheduler = allocation_service_1.allocationService.isEnabled()
+        ? (allocation_service_1.allocationService.getScheduler()?.name ?? null)
+        : null;
+    const platform = os.platform();
+    return { ...detect(scheduler, platform), hostname: os.hostname(), platform, scheduler };
+}