feat: add integration link to each SQL block

Author: jankuca

src/notebooks/deepnote/integrations/integrationManager.ts

@@ -26,8 +26,11 @@ export class IntegrationManager implements IIntegrationManager {
 
     public activate(): void {
         // Register the manage integrations command
+        // The command can optionally receive an integration ID to select/configure
         this.extensionContext.subscriptions.push(
-            commands.registerCommand(Commands.ManageIntegrations, () => this.showIntegrationsUI())
+            commands.registerCommand(Commands.ManageIntegrations, (integrationId?: string) =>
+                this.showIntegrationsUI(integrationId)
+            )
         );
 
         // Listen for active notebook changes to update context
@@ -95,8 +98,9 @@ export class IntegrationManager implements IIntegrationManager {
 
     /**
      * Show the integrations management UI
+     * @param selectedIntegrationId Optional integration ID to select/configure immediately
      */
-    private async showIntegrationsUI(): Promise<void> {
+    private async showIntegrationsUI(selectedIntegrationId?: string): Promise<void> {
         const activeNotebook = window.activeNotebookEditor?.notebook;
 
         if (!activeNotebook || activeNotebook.notebookType !== 'deepnote') {
@@ -130,8 +134,8 @@ export class IntegrationManager implements IIntegrationManager {
             return;
         }
 
-        // Show the webview
-        await this.webviewProvider.show(integrations);
+        // Show the webview with optional selected integration
+        await this.webviewProvider.show(integrations, selectedIntegrationId);
     }
 
     /**

src/notebooks/deepnote/integrations/integrationStorage.ts

@@ -1,4 +1,5 @@
 import { inject, injectable } from 'inversify';
+import { EventEmitter } from 'vscode';
 
 import { IEncryptedStorage } from '../../../platform/common/application/types';
 import { logger } from '../../../platform/logging';
@@ -17,6 +18,10 @@ export class IntegrationStorage {
 
     private cacheLoaded = false;
 
+    private readonly _onDidChangeIntegrations = new EventEmitter<void>();
+
+    public readonly onDidChangeIntegrations = this._onDidChangeIntegrations.event;
+
     constructor(@inject(IEncryptedStorage) private readonly encryptedStorage: IEncryptedStorage) {}
 
     /**
@@ -35,6 +40,15 @@ export class IntegrationStorage {
         return this.cache.get(integrationId);
     }
 
+    /**
+     * Get integration configuration for a specific project and integration
+     * Note: Currently integrations are stored globally, not per-project,
+     * so this method ignores the projectId parameter
+     */
+    async getIntegrationConfig(_projectId: string, integrationId: string): Promise<IntegrationConfig | undefined> {
+        return this.get(integrationId);
+    }
+
     /**
      * Get all integrations of a specific type
      */
@@ -58,6 +72,9 @@ export class IntegrationStorage {
 
         // Update the index
         await this.updateIndex();
+
+        // Fire change event
+        this._onDidChangeIntegrations.fire();
     }
 
     /**
@@ -74,6 +91,9 @@ export class IntegrationStorage {
 
         // Update the index
         await this.updateIndex();
+
+        // Fire change event
+        this._onDidChangeIntegrations.fire();
     }
 
     /**

src/notebooks/deepnote/integrations/integrationWebview.ts

@@ -24,8 +24,10 @@ export class IntegrationWebviewProvider implements IIntegrationWebviewProvider {
 
     /**
      * Show the integration management webview
+     * @param integrations Map of integration IDs to their status
+     * @param selectedIntegrationId Optional integration ID to select/configure immediately
      */
-    public async show(integrations: Map<string, IntegrationWithStatus>): Promise<void> {
+    public async show(integrations: Map<string, IntegrationWithStatus>, selectedIntegrationId?: string): Promise<void> {
         // Update the stored integrations with the latest data
         this.integrations = integrations;
 
@@ -35,6 +37,11 @@ export class IntegrationWebviewProvider implements IIntegrationWebviewProvider {
         if (this.currentPanel) {
             this.currentPanel.reveal(column);
             await this.updateWebview();
+
+            // If a specific integration was requested, show its configuration form
+            if (selectedIntegrationId) {
+                await this.showConfigurationForm(selectedIntegrationId);
+            }
             return;
         }
 
@@ -76,6 +83,11 @@ export class IntegrationWebviewProvider implements IIntegrationWebviewProvider {
         );
 
         await this.updateWebview();
+
+        // If a specific integration was requested, show its configuration form
+        if (selectedIntegrationId) {
+            await this.showConfigurationForm(selectedIntegrationId);
+        }
     }
 
     /**

src/notebooks/deepnote/integrations/types.ts

@@ -1,9 +1,21 @@
+import { Event } from 'vscode';
 import { IntegrationConfig, IntegrationWithStatus } from './integrationTypes';
 
 export const IIntegrationStorage = Symbol('IIntegrationStorage');
 export interface IIntegrationStorage {
+    /**
+     * Event fired when integrations change
+     */
+    readonly onDidChangeIntegrations: Event<void>;
+
     getAll(): Promise<IntegrationConfig[]>;
     get(integrationId: string): Promise<IntegrationConfig | undefined>;
+
+    /**
+     * Get integration configuration for a specific project and integration
+     */
+    getIntegrationConfig(projectId: string, integrationId: string): Promise<IntegrationConfig | undefined>;
+
     save(config: IntegrationConfig): Promise<void>;
     delete(integrationId: string): Promise<void>;
     exists(integrationId: string): Promise<boolean>;
@@ -27,8 +39,10 @@ export const IIntegrationWebviewProvider = Symbol('IIntegrationWebviewProvider')
 export interface IIntegrationWebviewProvider {
     /**
      * Show the integration management webview
+     * @param integrations Map of integration IDs to their status
+     * @param selectedIntegrationId Optional integration ID to select/configure immediately
      */
-    show(integrations: Map<string, IntegrationWithStatus>): Promise<void>;
+    show(integrations: Map<string, IntegrationWithStatus>, selectedIntegrationId?: string): Promise<void>;
 }
 
 export const IIntegrationManager = Symbol('IIntegrationManager');

src/notebooks/deepnote/sqlCellStatusBarProvider.ts

@@ -0,0 +1,106 @@
+import {
+    CancellationToken,
+    EventEmitter,
+    NotebookCell,
+    NotebookCellStatusBarItem,
+    NotebookCellStatusBarItemProvider,
+    NotebookDocument,
+    ProviderResult,
+    notebooks
+} from 'vscode';
+import { inject, injectable } from 'inversify';
+
+import { IExtensionSyncActivationService } from '../../platform/activation/types';
+import { IDisposableRegistry } from '../../platform/common/types';
+import { Commands } from '../../platform/common/constants';
+import { IIntegrationStorage } from './integrations/types';
+import { DATAFRAME_SQL_INTEGRATION_ID } from './integrations/integrationTypes';
+
+/**
+ * Provides status bar items for SQL cells showing the integration name
+ */
+@injectable()
+export class SqlCellStatusBarProvider implements NotebookCellStatusBarItemProvider, IExtensionSyncActivationService {
+    private readonly _onDidChangeCellStatusBarItems = new EventEmitter<void>();
+
+    public readonly onDidChangeCellStatusBarItems = this._onDidChangeCellStatusBarItems.event;
+
+    constructor(
+        @inject(IDisposableRegistry) private readonly disposables: IDisposableRegistry,
+        @inject(IIntegrationStorage) private readonly integrationStorage: IIntegrationStorage
+    ) {}
+
+    public activate(): void {
+        // Register the status bar provider for Deepnote notebooks
+        this.disposables.push(notebooks.registerNotebookCellStatusBarItemProvider('deepnote', this));
+
+        // Listen for integration configuration changes to update status bar
+        this.disposables.push(
+            this.integrationStorage.onDidChangeIntegrations(() => {
+                this._onDidChangeCellStatusBarItems.fire();
+            })
+        );
+    }
+
+    public provideCellStatusBarItems(
+        cell: NotebookCell,
+        _token: CancellationToken
+    ): ProviderResult<NotebookCellStatusBarItem | NotebookCellStatusBarItem[]> {
+        // Only show status bar for SQL cells
+        if (cell.document.languageId !== 'sql') {
+            return undefined;
+        }
+
+        // Get the integration ID from cell metadata
+        const integrationId = this.getIntegrationId(cell);
+        if (!integrationId) {
+            return undefined;
+        }
+
+        // Don't show status bar for the internal DuckDB integration
+        if (integrationId === DATAFRAME_SQL_INTEGRATION_ID) {
+            return undefined;
+        }
+
+        return this.createStatusBarItem(cell.notebook, integrationId);
+    }
+
+    private getIntegrationId(cell: NotebookCell): string | undefined {
+        // Check cell metadata for sql_integration_id
+        const metadata = cell.metadata;
+        if (metadata && typeof metadata === 'object') {
+            const integrationId = (metadata as Record<string, unknown>).sql_integration_id;
+            if (typeof integrationId === 'string') {
+                return integrationId;
+            }
+        }
+
+        return undefined;
+    }
+
+    private async createStatusBarItem(
+        notebook: NotebookDocument,
+        integrationId: string
+    ): Promise<NotebookCellStatusBarItem | undefined> {
+        const projectId = notebook.metadata?.deepnoteProjectId;
+        if (!projectId) {
+            return undefined;
+        }
+
+        // Get integration configuration to display the name
+        const config = await this.integrationStorage.getIntegrationConfig(projectId, integrationId);
+        const displayName = config?.name || integrationId;
+
+        // Create a status bar item that opens the integration management UI
+        return {
+            text: `$(database) ${displayName}`,
+            alignment: 1, // NotebookCellStatusBarAlignment.Left
+            tooltip: `SQL Integration: ${displayName}\nClick to configure`,
+            command: {
+                title: 'Configure Integration',
+                command: Commands.ManageIntegrations,
+                arguments: [integrationId]
+            }
+        };
+    }
+}