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';
@@ -12,6 +12,7 @@ import { STANDARD_OUTPUT_CHANNEL } from '../../platform/common/constants';
 import { sleep } from '../../platform/common/utils/async';
 import { Cancellation, raceCancellationError } from '../../platform/common/cancellation';
 import { IExtensionSyncActivationService } from '../../platform/activation/types';
+import { ISqlIntegrationEnvVarsProvider } from '../../platform/notebooks/deepnote/types';
 import getPort from 'get-port';
 import * as fs from 'fs-extra';
 import * as os from 'os';
@@ -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(ISqlIntegrationEnvVarsProvider)
+        @optional()
+        private readonly sqlIntegrationEnvVars?: ISqlIntegrationEnvVarsProvider
     ) {
         // Register for disposal when the extension deactivates
         asyncRegistry.push(this);
@@ -149,10 +153,28 @@ 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.debug(`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.debug(`DeepnoteServerStarter: Injecting ${Object.keys(sqlEnvVars).length} SQL env vars`);
+                    Object.assign(env, sqlEnvVars);
+                } else {
+                    logger.debug('DeepnoteServerStarter: No SQL integration env vars to inject');
+                }
+            } catch (error) {
+                logger.error('DeepnoteServerStarter: Failed to get SQL integration env vars', error.message);
+            }
+        } else {
+            logger.debug('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,315 @@ suite('Kernel Connection Helpers', () => {
             assert.strictEqual(name, '.env (Python 9.8.7)');
         });
     });
+
+    suite('executeSilently', () => {
+        interface MockKernelOptions {
+            status: 'ok' | 'error';
+            messages?: Array<{
+                msg_type: 'stream' | 'error' | 'display_data' | 'execute_result';
+                content: any;
+            }>;
+            errorContent?: {
+                ename: string;
+                evalue: string;
+                traceback: string[];
+            };
+        }
+
+        function createMockKernel(options: MockKernelOptions) {
+            return {
+                requestExecute: () => {
+                    let resolvePromise: (value: any) => void;
+
+                    // Create a promise that will be resolved after IOPub messages are dispatched
+                    const donePromise = new Promise<any>((resolve) => {
+                        resolvePromise = resolve;
+                    });
+
+                    return {
+                        done: donePromise,
+                        set onIOPub(cb: (msg: any) => void) {
+                            // Invoke IOPub callback synchronously with all messages
+                            if (options.messages && options.messages.length > 0) {
+                                options.messages.forEach((msg) => {
+                                    cb({
+                                        header: { msg_type: msg.msg_type },
+                                        content: msg.content
+                                    });
+                                });
+                            }
+                            // Resolve the done promise after messages are dispatched
+                            resolvePromise({
+                                content:
+                                    options.status === 'ok'
+                                        ? { status: 'ok' as const }
+                                        : {
+                                              status: 'error' as const,
+                                              ...options.errorContent
+                                          }
+                            });
+                        }
+                    };
+                }
+            };
+        }
+
+        test('Returns outputs from kernel execution', async () => {
+            const mockKernel = createMockKernel({
+                status: 'ok',
+                messages: [
+                    {
+                        msg_type: 'stream',
+                        content: {
+                            name: 'stdout',
+                            text: 'hello\n'
+                        }
+                    }
+                ]
+            });
+
+            const code = 'print("hello")';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            // executeSilently should return outputs array with collected stream output
+            assert.isArray(result);
+            assert.equal(result.length, 1);
+            assert.equal(result[0].output_type, 'stream');
+            assert.equal((result[0] as any).name, 'stdout');
+            assert.equal((result[0] as any).text, 'hello\n');
+        });
+
+        test('Collects error outputs', async () => {
+            const mockKernel = createMockKernel({
+                status: 'error',
+                errorContent: {
+                    ename: 'NameError',
+                    evalue: 'name not defined',
+                    traceback: ['Traceback...']
+                },
+                messages: [
+                    {
+                        msg_type: 'error',
+                        content: {
+                            ename: 'NameError',
+                            evalue: 'name not defined',
+                            traceback: ['Traceback...']
+                        }
+                    }
+                ]
+            });
+
+            const code = 'undefined_variable';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            assert.isArray(result);
+            assert.equal(result.length, 1);
+            assert.equal(result[0].output_type, 'error');
+            assert.equal((result[0] as any).ename, 'NameError');
+            assert.equal((result[0] as any).evalue, 'name not defined');
+            assert.deepStrictEqual((result[0] as any).traceback, ['Traceback...']);
+        });
+
+        test('Collects display_data outputs', async () => {
+            const mockKernel = createMockKernel({
+                status: 'ok',
+                messages: [
+                    {
+                        msg_type: 'display_data',
+                        content: {
+                            data: {
+                                'text/plain': 'some data'
+                            },
+                            metadata: {}
+                        }
+                    }
+                ]
+            });
+
+            const code = 'display("data")';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            assert.isArray(result);
+            assert.equal(result.length, 1);
+            assert.equal(result[0].output_type, 'display_data');
+            assert.deepStrictEqual((result[0] as any).data, { 'text/plain': 'some data' });
+            assert.deepStrictEqual((result[0] as any).metadata, {});
+        });
+
+        test('Handles multiple outputs', async () => {
+            const mockKernel = createMockKernel({
+                status: 'ok',
+                messages: [
+                    {
+                        msg_type: 'stream',
+                        content: {
+                            name: 'stdout',
+                            text: 'output 1'
+                        }
+                    },
+                    {
+                        msg_type: 'stream',
+                        content: {
+                            name: 'stdout',
+                            text: 'output 2'
+                        }
+                    }
+                ]
+            });
+
+            const code = 'print("1"); print("2")';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            assert.isArray(result);
+            // Consecutive stream messages with the same name are concatenated
+            assert.equal(result.length, 1);
+            assert.equal(result[0].output_type, 'stream');
+            assert.equal((result[0] as any).name, 'stdout');
+            assert.equal((result[0] as any).text, 'output 1output 2');
+        });
+
+        test('Collects execute_result outputs', async () => {
+            const mockKernel = createMockKernel({
+                status: 'ok',
+                messages: [
+                    {
+                        msg_type: 'execute_result',
+                        content: {
+                            data: {
+                                'text/plain': '42'
+                            },
+                            metadata: {},
+                            execution_count: 1
+                        }
+                    }
+                ]
+            });
+
+            const code = '42';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            assert.isArray(result);
+            assert.equal(result.length, 1);
+            assert.equal(result[0].output_type, 'execute_result');
+            assert.deepStrictEqual((result[0] as any).data, { 'text/plain': '42' });
+            assert.deepStrictEqual((result[0] as any).metadata, {});
+            assert.equal((result[0] as any).execution_count, 1);
+        });
+
+        test('Stream messages with different names produce separate outputs', async () => {
+            const mockKernel = createMockKernel({
+                status: 'ok',
+                messages: [
+                    {
+                        msg_type: 'stream',
+                        content: {
+                            name: 'stdout',
+                            text: 'standard output'
+                        }
+                    },
+                    {
+                        msg_type: 'stream',
+                        content: {
+                            name: 'stderr',
+                            text: 'error output'
+                        }
+                    },
+                    {
+                        msg_type: 'stream',
+                        content: {
+                            name: 'stdout',
+                            text: ' more stdout'
+                        }
+                    }
+                ]
+            });
+
+            const code = 'print("test")';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code);
+
+            assert.isArray(result);
+            // Should have 3 outputs: stdout, stderr, stdout (not concatenated because stderr is in between)
+            assert.equal(result.length, 3);
+            assert.equal(result[0].output_type, 'stream');
+            assert.equal((result[0] as any).name, 'stdout');
+            assert.equal((result[0] as any).text, 'standard output');
+            assert.equal(result[1].output_type, 'stream');
+            assert.equal((result[1] as any).name, 'stderr');
+            assert.equal((result[1] as any).text, 'error output');
+            assert.equal(result[2].output_type, 'stream');
+            assert.equal((result[2] as any).name, 'stdout');
+            assert.equal((result[2] as any).text, ' more stdout');
+        });
+
+        test('errorOptions with traceErrors logs errors', async () => {
+            const mockKernel = createMockKernel({
+                status: 'error',
+                errorContent: {
+                    ename: 'ValueError',
+                    evalue: 'invalid value',
+                    traceback: ['Traceback (most recent call last):', '  File "<stdin>", line 1']
+                },
+                messages: [
+                    {
+                        msg_type: 'error',
+                        content: {
+                            ename: 'ValueError',
+                            evalue: 'invalid value',
+                            traceback: ['Traceback (most recent call last):', '  File "<stdin>", line 1']
+                        }
+                    }
+                ]
+            });
+
+            const code = 'raise ValueError("invalid value")';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code, {
+                traceErrors: true,
+                traceErrorsMessage: 'Custom error message'
+            });
+
+            assert.isArray(result);
+            assert.equal(result.length, 1);
+            assert.equal(result[0].output_type, 'error');
+            assert.equal((result[0] as any).ename, 'ValueError');
+        });
+
+        test('errorOptions without traceErrors still collects errors', async () => {
+            const mockKernel = createMockKernel({
+                status: 'error',
+                errorContent: {
+                    ename: 'RuntimeError',
+                    evalue: 'runtime issue',
+                    traceback: ['Traceback...']
+                },
+                messages: [
+                    {
+                        msg_type: 'error',
+                        content: {
+                            ename: 'RuntimeError',
+                            evalue: 'runtime issue',
+                            traceback: ['Traceback...']
+                        }
+                    }
+                ]
+            });
+
+            const code = 'raise RuntimeError("runtime issue")';
+            const { executeSilently } = await import('./helpers');
+            const result = await executeSilently(mockKernel as any, code, {
+                traceErrors: false
+            });
+
+            assert.isArray(result);
+            assert.equal(result.length, 1);
+            assert.equal(result[0].output_type, 'error');
+            assert.equal((result[0] as any).ename, 'RuntimeError');
+        });
+    });
 });

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 });
             }