fix(e2e): fix kernel auto-launch and trust flow for fixture notebooks (#1046)

* fix(e2e): fix kernel auto-launch and trust flow for fixture notebooks

Three root causes addressed:

1. Fixture notebooks missing kernelspec metadata — added python3
   kernelspec to 1-vanilla.ipynb, 2-uv-inline.ipynb, and
   5-pyproject.ipynb. All passing fixtures already had kernelspec;
   without it, detect_runtime() returned None and the auto-launch
   took a less-tested code path.

2. detect_runtime() didn't infer Python from runt.uv/runt.conda —
   added fallback so notebooks with inline Python deps are correctly
   identified as Python even without a kernelspec. Three new tests
   cover this.

3. Trust-dependent E2E specs waited for kernel ready before handling
   trust — untrusted notebooks block auto-launch, so the kernel never
   starts. Restructured uv-inline and conda-inline specs to trigger
   execution first (surfacing the trust dialog), approve it, then wait
   for kernel ready.

Also:
- Improved auto-launch decision logging (always logs skip reason)
- getKernelStatus() helper now prefers data-kernel-status attribute
- Removed unused imports in prewarmed-uv spec

* fix(notebook-doc): use struct init to satisfy clippy field_reassign_with_default

Author: rgbkrk

crates/notebook-doc/src/metadata.rs

@@ -328,6 +328,11 @@ impl NotebookMetadataSnapshot {
             return Some("deno".to_string());
         }
 
+        // Fall back to runt.uv or runt.conda presence — these are implicitly Python
+        if self.runt.uv.is_some() || self.runt.conda.is_some() {
+            return Some("python".to_string());
+        }
+
         None
     }
 
@@ -898,6 +903,60 @@ mod tests {
         assert_eq!(s.detect_runtime(), Some("deno".to_string()));
     }
 
+    #[test]
+    fn test_detect_runtime_runt_uv_fallback() {
+        let s = NotebookMetadataSnapshot {
+            runt: RuntMetadata {
+                uv: Some(UvInlineMetadata {
+                    dependencies: vec!["requests".to_string()],
+                    requires_python: None,
+                    prerelease: None,
+                }),
+                ..RuntMetadata::default()
+            },
+            ..Default::default()
+        };
+        assert_eq!(s.detect_runtime(), Some("python".to_string()));
+    }
+
+    #[test]
+    fn test_detect_runtime_runt_conda_fallback() {
+        let s = NotebookMetadataSnapshot {
+            runt: RuntMetadata {
+                conda: Some(CondaInlineMetadata {
+                    dependencies: vec!["numpy".to_string()],
+                    channels: vec!["conda-forge".to_string()],
+                    python: None,
+                }),
+                ..RuntMetadata::default()
+            },
+            ..Default::default()
+        };
+        assert_eq!(s.detect_runtime(), Some("python".to_string()));
+    }
+
+    #[test]
+    fn test_detect_runtime_kernelspec_takes_priority_over_runt_uv() {
+        // kernelspec should still win even if runt.uv is present
+        let s = NotebookMetadataSnapshot {
+            kernelspec: Some(KernelspecSnapshot {
+                name: "deno".to_string(),
+                display_name: "Deno".to_string(),
+                language: Some("typescript".to_string()),
+            }),
+            runt: RuntMetadata {
+                uv: Some(UvInlineMetadata {
+                    dependencies: vec!["requests".to_string()],
+                    requires_python: None,
+                    prerelease: None,
+                }),
+                ..RuntMetadata::default()
+            },
+            ..Default::default()
+        };
+        assert_eq!(s.detect_runtime(), Some("deno".to_string()));
+    }
+
     #[test]
     fn test_detect_runtime_none_for_empty_metadata() {
         let s = NotebookMetadataSnapshot::default();

crates/notebook/fixtures/audit-test/1-vanilla.ipynb

@@ -2,6 +2,11 @@
   "nbformat": 4,
   "nbformat_minor": 5,
   "metadata": {
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3",
+      "language": "python"
+    },
     "runt": {
       "schema_version": "1"
     }

crates/notebook/fixtures/audit-test/2-uv-inline.ipynb

@@ -13,6 +13,11 @@
     }
   ],
   "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
     "runt": {
       "env_id": "fixture-uv-inline",
       "uv": {

crates/notebook/fixtures/audit-test/pyproject-project/5-pyproject.ipynb

@@ -13,6 +13,11 @@
     }
   ],
   "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
     "runt": {
       "env_id": "fixture-pyproject"
     }

crates/runtimed/src/notebook_sync_server.rs

@@ -954,7 +954,7 @@ where
         let is_new_notebook =
             !notebook_path_snapshot.exists() && uuid::Uuid::parse_str(&notebook_id).is_ok();
 
-        let (should_auto_launch, trust_status) = {
+        let (should_auto_launch, trust_status, has_kernel) = {
             let trust_state = room.trust_state.read().await;
             let has_kernel = room.has_kernel().await;
             let status = trust_state.status.clone();
@@ -967,7 +967,7 @@ where
                 // For new notebooks (UUID, no file): NoDependencies is safe to auto-launch
                 // For newly-created notebooks at a path: also safe to auto-launch
                 && (notebook_path_snapshot.exists() || is_new_notebook || created_new_at_path);
-            (should_launch, status)
+            (should_launch, status, has_kernel)
         };
 
         if should_auto_launch {
@@ -994,13 +994,11 @@ where
                 )
                 .await;
             });
-        } else if !matches!(
-            trust_status,
-            runt_trust::TrustStatus::Trusted | runt_trust::TrustStatus::NoDependencies
-        ) {
+        } else {
             info!(
-                "[notebook-sync] Notebook {} not trusted, skipping auto-launch (status: {:?})",
-                notebook_id, trust_status
+                "[notebook-sync] Auto-launch skipped for {} (trust: {:?}, has_kernel: {}, path_exists: {}, is_new: {}, created_at_path: {})",
+                notebook_id, trust_status, has_kernel,
+                notebook_path_snapshot.exists(), is_new_notebook, created_new_at_path
             );
         }
     }

e2e/helpers.js

@@ -284,6 +284,14 @@ export async function approveTrustDialog(timeout = 15000) {
  */
 export async function getKernelStatus() {
   return await browser.execute(() => {
+    // Prefer the data-kernel-status attribute (added in #1041) — it reflects
+    // the raw status enum value and doesn't depend on DOM text rendering.
+    const statusEl = document.querySelector('[data-testid="kernel-status"]');
+    if (statusEl) {
+      const attr = statusEl.getAttribute("data-kernel-status");
+      if (attr) return attr.trim().toLowerCase();
+    }
+    // Fallback: read the visible status text from the toolbar
     const el = document.querySelector(
       '[data-testid="notebook-toolbar"] .capitalize',
     );

e2e/specs/conda-inline.spec.js

@@ -6,8 +6,10 @@
  *
  * Fixture: 3-conda-inline.ipynb (has markupsafe dependency via conda)
  *
- * Updated to use setCellSource + explicit button clicks for compatibility
- * with tauri-plugin-webdriver (synthetic keyboard events don't work).
+ * Flow: Notebooks with inline deps are untrusted by default. The kernel
+ * won't auto-launch until the user approves the trust dialog. This spec
+ * triggers execution to surface the dialog, approves it, then verifies
+ * the kernel starts with the correct conda inline environment.
  */
 
 import { browser } from "@wdio/globals";
@@ -20,9 +22,34 @@ import {
 } from "../helpers.js";
 
 describe("Conda Inline Dependencies", () => {
-  it("should auto-launch kernel (may need trust approval)", async () => {
+  it("should start kernel after trust approval", async () => {
+    console.log("[conda-inline] Waiting for notebook to sync...");
+    await waitForNotebookSynced();
+
+    // For untrusted notebooks, the kernel won't auto-launch.
+    // Trigger execution to surface the trust dialog.
+    const codeCell = await $('[data-cell-type="code"]');
+    await codeCell.waitForExist({ timeout: 10000 });
+
+    await setCellSource(codeCell, "import sys; print(sys.executable)");
+
+    const executeButton = await codeCell.$('[data-testid="execute-button"]');
+    await executeButton.waitForClickable({ timeout: 5000 });
+    await executeButton.click();
+    console.log("[conda-inline] Clicked execute to trigger trust dialog");
+
+    // Approve the trust dialog (inline deps require approval)
+    const approved = await approveTrustDialog(30000);
+    if (approved) {
+      console.log("[conda-inline] Trust dialog approved");
+    } else {
+      console.log(
+        "[conda-inline] No trust dialog appeared (may already be trusted)",
+      );
+    }
+
+    // Now wait for kernel to be ready (300s for conda env creation on cold CI)
     console.log("[conda-inline] Waiting for kernel ready (up to 300s)...");
-    // Wait for kernel or trust dialog (300s for first startup + conda env creation)
     await waitForKernelReady(300000);
     console.log("[conda-inline] Kernel is ready");
   });
@@ -46,48 +73,18 @@ describe("Conda Inline Dependencies", () => {
 
     expect(await depsToggle.getAttribute("data-env-manager")).toBe("conda");
     expect(await depsToggle.getAttribute("data-runtime")).toBe("python");
-    console.log("[conda-inline] Conda badge verified in toolbar");
   });
 
-  it("should have inline deps available after trust", async () => {
-    console.log("[conda-inline] Waiting for notebook to sync...");
-    await waitForNotebookSynced();
-
-    // Find the first code cell
+  it("should execute code in conda inline environment", async () => {
     const codeCell = await $('[data-cell-type="code"]');
     await codeCell.waitForExist({ timeout: 10000 });
-    console.log("[conda-inline] Found first code cell");
 
-    // Set the cell source via CodeMirror dispatch (bypasses keyboard events)
     await setCellSource(codeCell, "import sys; print(sys.executable)");
-    console.log("[conda-inline] Set cell source via setCellSource");
 
-    // Click the execute button
     const executeButton = await codeCell.$('[data-testid="execute-button"]');
     await executeButton.waitForClickable({ timeout: 5000 });
     await executeButton.click();
-    console.log("[conda-inline] Clicked execute button");
-
-    // May need to approve trust dialog for inline deps
-    const approved = await approveTrustDialog(15000);
-    if (approved) {
-      console.log(
-        "[conda-inline] Trust dialog approved, waiting for kernel restart...",
-      );
-      // If trust dialog appeared, wait for kernel to restart with deps
-      await waitForKernelReady(300000);
-      console.log("[conda-inline] Kernel restarted after trust approval");
 
-      // Re-execute after kernel restart by clicking the button again
-      const reExecuteButton = await codeCell.$(
-        '[data-testid="execute-button"]',
-      );
-      await reExecuteButton.waitForClickable({ timeout: 5000 });
-      await reExecuteButton.click();
-      console.log("[conda-inline] Re-executed cell after kernel restart");
-    }
-
-    // Wait for output
     const output = await waitForCellOutput(codeCell, 120000);
     console.log(`[conda-inline] Cell output: ${output}`);
 
@@ -96,31 +93,21 @@ describe("Conda Inline Dependencies", () => {
   });
 
   it("should be able to import inline dependency", async () => {
-    // Find the cells — use a second cell if available, otherwise the first
     const cells = await $$('[data-cell-type="code"]');
     const cell = cells.length > 1 ? cells[1] : cells[0];
-    console.log(
-      `[conda-inline] Using cell index ${cells.length > 1 ? 1 : 0} for import test`,
-    );
 
-    // Set the cell source directly via CodeMirror dispatch
     await setCellSource(
       cell,
       "import markupsafe; print(markupsafe.__version__)",
     );
-    console.log("[conda-inline] Set import test source via setCellSource");
 
-    // Click the execute button
     const executeButton = await cell.$('[data-testid="execute-button"]');
     await executeButton.waitForClickable({ timeout: 5000 });
     await executeButton.click();
-    console.log("[conda-inline] Clicked execute button for import test");
 
-    // Wait for version output
     const output = await waitForCellOutput(cell, 30000);
     console.log(`[conda-inline] Import test output: ${output}`);
 
-    // Should show a version number (e.g., "1.26.4")
     expect(output).toMatch(/^\d+\.\d+/);
   });
 });

e2e/specs/prewarmed-uv.spec.js

@@ -12,9 +12,7 @@
 
 import { browser } from "@wdio/globals";
 import {
-  isManagedEnv,
   setCellSource,
-  waitForAppReady,
   waitForCellOutput,
   waitForKernelReady,
   waitForNotebookSynced,