Fix xeus-octave startup by retrying kernel_info and increasing timeout

xeus-octave was failing with "Connection reset by peer" or timeout
because Octave takes longer to initialize than other kernels. Two fixes:

1. Retry kernel_info_request up to 3 times with 2s delays between
   attempts, so slow-starting kernels get a chance to bind their ports
2. Increase per-test timeout to 30s for xeus-octave in CI

Author: rgbkrk

.github/workflows/conformance.yml

@@ -242,6 +242,7 @@ jobs:
         run: |
           if [ "${{ matrix.kernel.name }}" = "xeus-octave" ]; then
             xvfb-run -a ./target/release/jupyter-kernel-test ${{ matrix.kernel.kernel-name }} \
+              --timeout 30000 \
               --format json \
               --output ${{ matrix.kernel.name }}-report.json
           else
@@ -254,7 +255,7 @@ jobs:
       - name: Display results
         run: |
           if [ "${{ matrix.kernel.name }}" = "xeus-octave" ]; then
-            xvfb-run -a ./target/release/jupyter-kernel-test ${{ matrix.kernel.kernel-name }} || true
+            xvfb-run -a ./target/release/jupyter-kernel-test ${{ matrix.kernel.kernel-name }} --timeout 30000 || true
           else
             ./target/release/jupyter-kernel-test ${{ matrix.kernel.kernel-name }} || true
           fi

src/harness.rs

@@ -182,29 +182,50 @@ impl KernelUnderTest {
     }
 
     /// Fetch kernel_info and update snippets.
+    ///
+    /// Retries the kernel_info_request up to 3 times to handle slow-starting
+    /// kernels (e.g., xeus-octave) where the initial request may be sent before
+    /// the kernel has bound to its ports.
     async fn fetch_kernel_info(&mut self) -> Result<()> {
-        let request: JupyterMessage = KernelInfoRequest {}.into();
-        self.shell
-            .send(request)
-            .await
-            .map_err(|e| HarnessError::ProtocolError(e.to_string()))?;
+        let max_attempts = 3;
+        let mut last_error = None;
 
-        // Read reply with timeout
-        let reply = timeout(self.test_timeout, self.shell.read())
-            .await
-            .map_err(|_| HarnessError::Timeout("kernel_info_reply".to_string()))?
-            .map_err(|e| HarnessError::ProtocolError(e.to_string()))?;
+        for attempt in 0..max_attempts {
+            if attempt > 0 {
+                // Wait longer between retries to give the kernel time to start
+                tokio::time::sleep(Duration::from_secs(2)).await;
+            }
 
-        if let JupyterMessageContent::KernelInfoReply(info) = reply.content {
-            self.snippets = LanguageSnippets::for_language(&info.language_info.name);
-            self.kernel_info = Some(*info);
-            Ok(())
-        } else {
-            Err(HarnessError::ProtocolError(format!(
-                "Expected kernel_info_reply, got {:?}",
-                reply.content.message_type()
-            )))
+            let request: JupyterMessage = KernelInfoRequest {}.into();
+            if let Err(e) = self.shell.send(request).await {
+                last_error = Some(HarnessError::ProtocolError(e.to_string()));
+                continue;
+            }
+
+            match timeout(self.test_timeout, self.shell.read()).await {
+                Ok(Ok(reply)) => {
+                    if let JupyterMessageContent::KernelInfoReply(info) = reply.content {
+                        self.snippets =
+                            LanguageSnippets::for_language(&info.language_info.name);
+                        self.kernel_info = Some(*info);
+                        return Ok(());
+                    } else {
+                        return Err(HarnessError::ProtocolError(format!(
+                            "Expected kernel_info_reply, got {:?}",
+                            reply.content.message_type()
+                        )));
+                    }
+                }
+                Ok(Err(e)) => {
+                    last_error = Some(HarnessError::ProtocolError(e.to_string()));
+                }
+                Err(_) => {
+                    last_error = Some(HarnessError::Timeout("kernel_info_reply".to_string()));
+                }
+            }
         }
+
+        Err(last_error.unwrap_or_else(|| HarnessError::Timeout("kernel_info_reply".to_string())))
     }
 
     /// Get kernel info.