Manage ggsql kernel spec in Positron extension

Author: georgestagg

ggsql-jupyter/src/main.rs

@@ -122,7 +122,9 @@ fn install_kernel(user: bool, sys_prefix: bool) -> Result<()> {
         "display_name": "ggsql",
         "language": "ggsql",
         "interrupt_mode": "signal",
-        "env": {},
+        "env": {
+            "RUST_LOG": "error"
+        },
         "metadata": {
             "debugger": false
         }

ggsql-vscode/src/manager.ts

@@ -14,58 +14,109 @@ import type { JupyterKernelSpec, JupyterSession, JupyterKernel, PositronSupervis
 import { log } from './extension';
 
 /**
- * Get the path to the ggsql-jupyter kernel executable
+ * A discovered ggsql-jupyter kernel candidate
+ */
+interface KernelCandidate {
+    /** Absolute path to the ggsql-jupyter binary (or bare name for PATH fallback) */
+    kernelPath: string;
+    /** Human-readable label for where this was found */
+    source: string;
+}
+
+/**
+ * Discover all available ggsql-jupyter kernel binaries
  *
- * Checks in order:
+ * Checks in priority order:
  * 1. Configured path in settings
- * 2. Jupyter kernelspec location (user)
- * 3. Jupyter kernelspec location (system)
+ * 2. Jupyter kernelspec locations (user and system)
+ * 3. Cargo-packager install locations
  * 4. Fall back to PATH
+ *
+ * Returns deduplicated candidates, keeping the highest-priority occurrence.
  */
-function getKernelPath(): string {
+function discoverKernelPaths(): KernelCandidate[] {
+    const candidates: KernelCandidate[] = [];
+    const binaryName = process.platform === 'win32' ? 'ggsql-jupyter.exe' : 'ggsql-jupyter';
+
+    // 1. User-configured setting (highest priority)
     const config = vscode.workspace.getConfiguration('ggsql');
     const configuredPath = config.get<string>('kernelPath', '');
-
     if (configuredPath && configuredPath.trim() !== '') {
-        return configuredPath;
+        candidates.push({ kernelPath: configuredPath, source: 'setting' });
     }
 
-    // Check Jupyter kernelspec locations
+    // 2. Jupyter kernelspec locations
     const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-    const kernelName = 'ggsql';
-    const binaryName = process.platform === 'win32' ? 'ggsql-jupyter.exe' : 'ggsql-jupyter';
-
-    // Common Jupyter kernel locations
-    const possiblePaths = [
-        // User kernelspec (macOS/Linux)
-        path.join(homeDir, 'Library', 'Jupyter', 'kernels', kernelName, binaryName),
+    const kernelspecPaths = [
+        // User kernelspec (macOS)
+        path.join(homeDir, 'Library', 'Jupyter', 'kernels', 'ggsql', binaryName),
         // User kernelspec (Linux)
-        path.join(homeDir, '.local', 'share', 'jupyter', 'kernels', kernelName, binaryName),
+        path.join(homeDir, '.local', 'share', 'jupyter', 'kernels', 'ggsql', binaryName),
         // System kernelspec (macOS)
-        path.join('/usr', 'local', 'share', 'jupyter', 'kernels', kernelName, binaryName),
+        path.join('/usr', 'local', 'share', 'jupyter', 'kernels', 'ggsql', binaryName),
         // System kernelspec (Linux)
-        path.join('/usr', 'share', 'jupyter', 'kernels', kernelName, binaryName),
+        path.join('/usr', 'share', 'jupyter', 'kernels', 'ggsql', binaryName),
     ];
+    for (const p of kernelspecPaths) {
+        if (fs.existsSync(p)) {
+            candidates.push({ kernelPath: p, source: 'Jupyter' });
+        }
+    }
+
+    // 3. Cargo-packager install locations
+    const packagerPaths: string[] = [];
+    if (process.platform === 'darwin') {
+        packagerPaths.push('/Applications/ggsql.app/Contents/MacOS/ggsql-jupyter');
+    } else if (process.platform === 'win32') {
+        const programFiles = process.env.PROGRAMFILES || 'C:\\Program Files';
+        packagerPaths.push(path.join(programFiles, 'ggsql', 'ggsql-jupyter.exe'));
+        const localAppData = process.env.LOCALAPPDATA;
+        if (localAppData) {
+            packagerPaths.push(path.join(localAppData, 'ggsql', 'ggsql-jupyter.exe'));
+        }
+    } else {
+        // Linux deb package
+        packagerPaths.push('/usr/bin/ggsql-jupyter');
+    }
+    for (const p of packagerPaths) {
+        if (fs.existsSync(p)) {
+            candidates.push({ kernelPath: p, source: 'System' });
+        }
+    }
 
-    for (const kernelPath of possiblePaths) {
-        if (fs.existsSync(kernelPath)) {
-            log(`Found kernel at: ${kernelPath}`);
-            return kernelPath;
+    // 4. PATH fallback (last resort)
+    candidates.push({ kernelPath: binaryName, source: 'Path' });
+
+    // Deduplicate by resolved absolute path
+    const seen = new Set<string>();
+    const deduped: KernelCandidate[] = [];
+    for (const candidate of candidates) {
+        if (!path.isAbsolute(candidate.kernelPath)) {
+            // Non-absolute paths (PATH fallback) can't be deduplicated
+            deduped.push(candidate);
+            continue;
+        }
+        let resolved: string;
+        try {
+            resolved = fs.realpathSync(candidate.kernelPath);
+        } catch {
+            resolved = candidate.kernelPath;
+        }
+        if (!seen.has(resolved)) {
+            seen.add(resolved);
+            deduped.push(candidate);
+        } else {
+            log(`Skipping duplicate kernel path: ${candidate.kernelPath} (resolves to ${resolved})`);
         }
     }
 
-    // Fall back to PATH
-    log('Kernel not found in standard locations, falling back to PATH');
-    return 'ggsql-jupyter';
+    return deduped;
 }
 
 /**
- * Check if the kernel executable exists and is accessible
+ * Check if a kernel executable exists and is accessible
  */
-async function isKernelAvailable(): Promise<boolean> {
-    const kernelPath = getKernelPath();
-
-    // If it's an absolute path, check if the file exists
+async function isKernelAccessible(kernelPath: string): Promise<boolean> {
     if (path.isAbsolute(kernelPath)) {
         try {
             await fs.promises.access(kernelPath, fs.constants.X_OK);
@@ -81,21 +132,22 @@ async function isKernelAvailable(): Promise<boolean> {
 }
 
 /**
- * Generate runtime metadata for ggsql
+ * Generate runtime metadata for a ggsql kernel candidate
  */
 function generateMetadata(
-    context: vscode.ExtensionContext
+    context: vscode.ExtensionContext,
+    candidate: KernelCandidate,
+    index: number
 ): positron.LanguageRuntimeMetadata {
-    const kernelPath = getKernelPath();
     const version = context.extension.packageJSON.version as string;
 
     const iconPath = path.join(context.extensionPath, 'resources', 'ggsql-icon.svg');
     const base64Icon = fs.readFileSync(iconPath).toString('base64');
 
     return {
-        runtimeId: 'ggsql-jupyter',
-        runtimePath: kernelPath,
-        runtimeName: `ggsql ${version}`,
+        runtimeId: index === 0 ? 'ggsql-jupyter' : `ggsql-jupyter-${index}`,
+        runtimePath: candidate.kernelPath,
+        runtimeName: `ggsql (${candidate.source})`,
         runtimeShortName: 'ggsql',
         runtimeVersion: version,
         runtimeSource: 'ggsql',
@@ -115,11 +167,10 @@ function generateMetadata(
  * Uses the startKernel callback to manually start the kernel process,
  * giving us more control over the launch process.
  *
+ * @param kernelPath - Path to the ggsql-jupyter executable
  * @param workspacePath - Optional workspace path to use as the kernel's working directory
  */
-function createKernelSpec(workspacePath?: string): JupyterKernelSpec {
-    const kernelPath = getKernelPath();
-
+function createKernelSpec(kernelPath: string, workspacePath?: string): JupyterKernelSpec {
     return {
         // argv is empty when using startKernel callback
         argv: [],
@@ -180,6 +231,95 @@ function createKernelSpec(workspacePath?: string): JupyterKernelSpec {
     };
 }
 
+/**
+ * Get the user-level Jupyter kernelspec directory for ggsql.
+ */
+function getUserJupyterKernelDir(): string {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    switch (process.platform) {
+        case 'darwin':
+            return path.join(homeDir, 'Library', 'Jupyter', 'kernels', 'ggsql');
+        case 'win32':
+            return path.join(
+                process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming'),
+                'jupyter', 'kernels', 'ggsql'
+            );
+        default:
+            return path.join(homeDir, '.local', 'share', 'jupyter', 'kernels', 'ggsql');
+    }
+}
+
+/**
+ * Get the Jupyter kernelspec directory for ggsql.
+ *
+ * If a Python virtual environment or non-base conda environment is active
+ * (detected via process.env), uses the environment-level path so that
+ * Jupyter's `prefer_environment_over_user()` precedence applies naturally.
+ * Otherwise falls back to the user-level kernelspec directory.
+ */
+function getJupyterKernelDir(): string {
+    // Prefer virtual environment path when active. Jupyter gives these
+    // precedence over user-level paths when running inside the same env.
+    const virtualEnv = process.env.VIRTUAL_ENV;
+    if (virtualEnv) {
+        return path.join(virtualEnv, 'share', 'jupyter', 'kernels', 'ggsql');
+    }
+
+    const condaPrefix = process.env.CONDA_PREFIX;
+    const condaEnv = process.env.CONDA_DEFAULT_ENV;
+    if (condaPrefix && condaEnv && condaEnv !== 'base') {
+        return path.join(condaPrefix, 'share', 'jupyter', 'kernels', 'ggsql');
+    }
+
+    return getUserJupyterKernelDir();
+}
+
+/**
+ * Write a ggsql kernel.json to the given directory.
+ *
+ * Only writes if the content has changed to avoid unnecessary disk writes.
+ */
+function writeKernelJson(kernelDir: string, kernelPath: string): void {
+    const kernelSpec = {
+        argv: [kernelPath, '-f', '{connection_file}'],
+        display_name: 'ggsql',
+        language: 'ggsql',
+        interrupt_mode: 'message',
+        env: { RUST_LOG: 'error' },
+        metadata: { debugger: false }
+    };
+
+    const kernelJsonPath = path.join(kernelDir, 'kernel.json');
+    const kernelSpecJson = JSON.stringify(kernelSpec, null, 2);
+
+    try {
+        const existing = fs.existsSync(kernelJsonPath)
+            ? fs.readFileSync(kernelJsonPath, 'utf8')
+            : null;
+
+        if (existing !== kernelSpecJson) {
+            fs.mkdirSync(kernelDir, { recursive: true });
+            fs.writeFileSync(kernelJsonPath, kernelSpecJson);
+            log(`Wrote ggsql kernel spec to ${kernelJsonPath}`);
+        }
+    } catch (err) {
+        log(`Failed to write ggsql kernel spec: ${err}`);
+    }
+}
+
+/**
+ * Install a Jupyter kernel spec for ggsql so that external tools like Quarto
+ * can discover it via `jupyter kernelspec list`.
+ *
+ * Writes kernel.json to the appropriate Jupyter kernelspec directory: the
+ * active virtualenv/conda env if detected, otherwise the user-level dir.
+ *
+ * @param kernelPath Absolute path to the ggsql-jupyter binary
+ */
+function installJupyterKernelSpec(kernelPath: string): void {
+    writeKernelJson(getJupyterKernelDir(), kernelPath);
+}
+
 /**
  * ggsql Language Runtime Manager
  *
@@ -196,22 +336,35 @@ export class GgsqlRuntimeManager implements positron.LanguageRuntimeManager {
     /**
      * Discover available ggsql runtimes.
      *
-     * Returns a single ggsql runtime if the kernel is available.
+     * Returns all accessible ggsql kernel binaries found on the system.
      */
     discoverAllRuntimes(): AsyncGenerator<positron.LanguageRuntimeMetadata> {
         const context = this._context;
 
         const generator = async function* discoverGgsqlRuntimes() {
             log('Discovering ggsql runtimes...');
 
-            // Check if the kernel is available
-            const available = await isKernelAvailable();
-            log(`Kernel available: ${available}`);
-
-            if (available) {
-                const metadata = generateMetadata(context);
-                log(`Yielding runtime: ${metadata.runtimeName} (${metadata.runtimeId})`);
-                yield metadata;
+            const candidates = discoverKernelPaths();
+            log(`Found ${candidates.length} kernel candidate(s)`);
+
+            let index = 0;
+            for (const candidate of candidates) {
+                const accessible = await isKernelAccessible(candidate.kernelPath);
+                if (accessible) {
+                    // When a system install is found, write the kernel spec to
+                    // the user kernelspec dir immediately so that Quarto/Jupyter
+                    // can discover ggsql even if no session is ever started.
+                    if (candidate.source === 'System') {
+                        writeKernelJson(getUserJupyterKernelDir(), candidate.kernelPath);
+                    }
+
+                    const metadata = generateMetadata(context, candidate, index);
+                    log(`Yielding runtime: ${metadata.runtimeName} (${metadata.runtimeId}) at ${candidate.kernelPath}`);
+                    yield metadata;
+                    index++;
+                } else {
+                    log(`Skipping inaccessible kernel: ${candidate.kernelPath}`);
+                }
             }
 
             log('Runtime discovery complete');
@@ -252,8 +405,8 @@ export class GgsqlRuntimeManager implements positron.LanguageRuntimeManager {
         const workspaceFolders = vscode.workspace.workspaceFolders;
         const workspacePath = workspaceFolders?.[0]?.uri.fsPath;
 
-        // Create the kernel spec
-        const kernelSpec = createKernelSpec(workspacePath);
+        // Create the kernel spec using the runtime's kernel path
+        const kernelSpec = createKernelSpec(runtimeMetadata.runtimePath, workspacePath);
 
         // Create the dynamic state
         const dynState: positron.LanguageRuntimeDynState = {
@@ -262,6 +415,9 @@ export class GgsqlRuntimeManager implements positron.LanguageRuntimeManager {
             sessionName: 'ggsql'
         };
 
+        // Advertise this kernel to external tools (Quarto, Jupyter)
+        installJupyterKernelSpec(runtimeMetadata.runtimePath);
+
         // Create the session using the supervisor
         const session = await supervisorApi.createSession(
             runtimeMetadata,
@@ -305,6 +461,9 @@ export class GgsqlRuntimeManager implements positron.LanguageRuntimeManager {
             sessionName: 'ggsql'
         };
 
+        // Re-advertise this kernel on restore
+        installJupyterKernelSpec(runtimeMetadata.runtimePath);
+
         const session = await supervisorApi.restoreSession(
             runtimeMetadata,
             sessionMetadata,