feat: SQL block credentials propagation to Jupyter kernel

src/kernels/deepnote/deepnoteServerStarter.node.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { inject, injectable, named } from 'inversify';
+import { inject, injectable, named, optional } from 'inversify';
 import { CancellationToken, Uri } from 'vscode';
 import { PythonEnvironment } from '../../platform/pythonEnvironments/info';
 import { IDeepnoteServerStarter, IDeepnoteToolkitInstaller, DeepnoteServerInfo, DEEPNOTE_DEFAULT_PORT } from './types';
@@ -17,6 +17,7 @@ import * as fs from 'fs-extra';
 import * as os from 'os';
 import * as path from '../../platform/vscode-path/path';
 import { generateUuid } from '../../platform/common/uuid';
+import { SqlIntegrationEnvironmentVariablesProvider } from '../../platform/notebooks/deepnote/sqlIntegrationEnvironmentVariablesProvider';
 
 /**
  * Lock file data structure for tracking server ownership
@@ -47,7 +48,10 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
         @inject(IDeepnoteToolkitInstaller) private readonly toolkitInstaller: IDeepnoteToolkitInstaller,
         @inject(IOutputChannel) @named(STANDARD_OUTPUT_CHANNEL) private readonly outputChannel: IOutputChannel,
         @inject(IHttpClient) private readonly httpClient: IHttpClient,
-        @inject(IAsyncDisposableRegistry) asyncRegistry: IAsyncDisposableRegistry
+        @inject(IAsyncDisposableRegistry) asyncRegistry: IAsyncDisposableRegistry,
+        @inject(SqlIntegrationEnvironmentVariablesProvider)
+        @optional()
+        private readonly sqlIntegrationEnvVars?: SqlIntegrationEnvironmentVariablesProvider
     ) {
         // Register for disposal when the extension deactivates
         asyncRegistry.push(this);
@@ -149,10 +153,33 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
 
         // Detached mode ensures no requests are made to the backend (directly, or via proxy)
         // as there is no backend running in the extension, therefore:
-        // 1. integration environment variables won't work / be injected
+        // 1. integration environment variables are injected here instead
         // 2. post start hooks won't work / are not executed
         env.DEEPNOTE_RUNTIME__RUNNING_IN_DETACHED_MODE = 'true';
 
+        // Inject SQL integration environment variables
+        if (this.sqlIntegrationEnvVars) {
+            logger.info(`DeepnoteServerStarter: Injecting SQL integration env vars for ${deepnoteFileUri.toString()}`);
+            try {
+                const sqlEnvVars = await this.sqlIntegrationEnvVars.getEnvironmentVariables(deepnoteFileUri, token);
+                if (sqlEnvVars && Object.keys(sqlEnvVars).length > 0) {
+                    logger.info(
+                        `DeepnoteServerStarter: Injecting ${
+                            Object.keys(sqlEnvVars).length
+                        } SQL integration env vars: ${Object.keys(sqlEnvVars).join(', ')}`
+                    );
+                    Object.assign(env, sqlEnvVars);
+                    logger.info(`DeepnoteServerStarter: Injected SQL env vars: ${Object.keys(sqlEnvVars).join(', ')}`);
+                } else {
+                    logger.info('DeepnoteServerStarter: No SQL integration env vars to inject');
+                }
+            } catch (error) {
+                logger.error('DeepnoteServerStarter: Failed to get SQL integration env vars', error);
+            }
+        } else {
+            logger.info('DeepnoteServerStarter: SqlIntegrationEnvironmentVariablesProvider not available');
+        }
+
         // Remove PYTHONHOME if it exists (can interfere with venv)
         delete env.PYTHONHOME;
 

src/kernels/helpers.unit.test.ts

@@ -646,4 +646,219 @@ suite('Kernel Connection Helpers', () => {
             assert.strictEqual(name, '.env (Python 9.8.7)');
         });
     });
+
+    suite('executeSilently', () => {
+        test('Returns outputs from kernel execution', async () => {
+            const mockKernel = {
+                requestExecute: () => ({
+                    done: Promise.resolve({
+                        content: {
+                            status: 'ok' as const
+                        }
+                    }),
+                    onIOPub: () => {
+                        // noop
+                    }
+                })
+            };
+
+            const code = 'print("hello")';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            // executeSilently should return outputs array
+            assert.isArray(result);
+        });
+
+        test('Handles empty code', async () => {
+            const mockKernel = {
+                requestExecute: () => ({
+                    done: Promise.resolve({
+                        content: {
+                            status: 'ok' as const
+                        }
+                    }),
+                    onIOPub: () => {
+                        // noop
+                    }
+                })
+            };
+
+            const code = '';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            // Should return empty array for empty code
+            assert.isArray(result);
+        });
+
+        test('Collects stream outputs', async () => {
+            let iopubCallback: ((msg: any) => void) | undefined;
+
+            const mockKernel = {
+                requestExecute: () => ({
+                    done: Promise.resolve({
+                        content: {
+                            status: 'ok' as const
+                        }
+                    }),
+                    onIOPub: (cb: (msg: any) => void) => {
+                        iopubCallback = cb;
+                        // Simulate stream output
+                        setTimeout(() => {
+                            if (iopubCallback) {
+                                iopubCallback({
+                                    header: { msg_type: 'stream' },
+                                    content: {
+                                        name: 'stdout',
+                                        text: 'test output'
+                                    }
+                                });
+                            }
+                        }, 0);
+                    }
+                })
+            };
+
+            const code = 'print("test")';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            assert.isArray(result);
+            // Should have collected the stream output
+            if (result && result.length > 0) {
+                assert.equal(result[0].output_type, 'stream');
+            }
+        });
+
+        test('Collects error outputs', async () => {
+            let iopubCallback: ((msg: any) => void) | undefined;
+
+            const mockKernel = {
+                requestExecute: () => ({
+                    done: Promise.resolve({
+                        content: {
+                            status: 'error' as const,
+                            ename: 'NameError',
+                            evalue: 'name not defined',
+                            traceback: ['Traceback...']
+                        }
+                    }),
+                    onIOPub: (cb: (msg: any) => void) => {
+                        iopubCallback = cb;
+                        // Simulate error output
+                        setTimeout(() => {
+                            if (iopubCallback) {
+                                iopubCallback({
+                                    header: { msg_type: 'error' },
+                                    content: {
+                                        ename: 'NameError',
+                                        evalue: 'name not defined',
+                                        traceback: ['Traceback...']
+                                    }
+                                });
+                            }
+                        }, 0);
+                    }
+                })
+            };
+
+            const code = 'undefined_variable';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            assert.isArray(result);
+            // Should have collected the error output
+            if (result && result.length > 0) {
+                assert.equal(result[0].output_type, 'error');
+            }
+        });
+
+        test('Collects display_data outputs', async () => {
+            let iopubCallback: ((msg: any) => void) | undefined;
+
+            const mockKernel = {
+                requestExecute: () => ({
+                    done: Promise.resolve({
+                        content: {
+                            status: 'ok' as const
+                        }
+                    }),
+                    onIOPub: (cb: (msg: any) => void) => {
+                        iopubCallback = cb;
+                        // Simulate display_data output
+                        setTimeout(() => {
+                            if (iopubCallback) {
+                                iopubCallback({
+                                    header: { msg_type: 'display_data' },
+                                    content: {
+                                        data: {
+                                            'text/plain': 'some data'
+                                        },
+                                        metadata: {}
+                                    }
+                                });
+                            }
+                        }, 0);
+                    }
+                })
+            };
+
+            const code = 'display("data")';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            assert.isArray(result);
+            // Should have collected the display_data output
+            if (result && result.length > 0) {
+                assert.equal(result[0].output_type, 'display_data');
+            }
+        });
+
+        test('Handles multiple outputs', async () => {
+            let iopubCallback: ((msg: any) => void) | undefined;
+
+            const mockKernel = {
+                requestExecute: () => ({
+                    done: Promise.resolve({
+                        content: {
+                            status: 'ok' as const
+                        }
+                    }),
+                    onIOPub: (cb: (msg: any) => void) => {
+                        iopubCallback = cb;
+                        // Simulate multiple outputs
+                        setTimeout(() => {
+                            if (iopubCallback) {
+                                iopubCallback({
+                                    header: { msg_type: 'stream' },
+                                    content: {
+                                        name: 'stdout',
+                                        text: 'output 1'
+                                    }
+                                });
+                                iopubCallback({
+                                    header: { msg_type: 'stream' },
+                                    content: {
+                                        name: 'stdout',
+                                        text: 'output 2'
+                                    }
+                                });
+                            }
+                        }, 0);
+                    }
+                })
+            };
+
+            const code = 'print("1"); print("2")';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            assert.isArray(result);
+            // Should have collected multiple outputs
+            if (result) {
+                assert.isAtLeast(result.length, 0);
+            }
+        });
+    });
 });

src/kernels/kernel.ts

@@ -853,10 +853,22 @@ abstract class BaseKernel implements IBaseKernel {
 
                 // Gather all of the startup code at one time and execute as one cell
                 const startupCode = await this.gatherInternalStartupCode();
-                await this.executeSilently(session, startupCode, {
+                logger.trace(`Executing startup code with ${startupCode.length} lines`);
+
+                const outputs = await this.executeSilently(session, startupCode, {
                     traceErrors: true,
                     traceErrorsMessage: 'Error executing jupyter extension internal startup code'
                 });
+                logger.trace(`Startup code execution completed with ${outputs?.length || 0} outputs`);
+                if (outputs && outputs.length > 0) {
+                    // Avoid logging content; output types only.
+                    logger.trace(
+                        `Startup code produced ${outputs.length} output(s): ${outputs
+                            .map((o) => o.output_type)
+                            .join(', ')}`
+                    );
+                }
+
                 // Run user specified startup commands
                 await this.executeSilently(session, this.getUserStartupCommands(), { traceErrors: false });
             }