fix: resolve merge conflicts with main

- Restore integration-related files and imports from main
- Accept main's new integration panel localization strings
- Restore SqlCellStatusBarProvider registration
- Restore missing integrationDetector.ts file

Author: devin-ai-integration[bot]

package-lock.json

@@ -158,6 +158,52 @@ export type LocalizedMessages = {
     selectedImageListLabel: string;
     selectedImageLabel: string;
     dvDeprecationWarning: string;
+    dataframeRowsColumns: string;
+    dataframePerPage: string;
+    dataframePreviousPage: string;
+    dataframeNextPage: string;
+    dataframePageOf: string;
+    dataframeCopyTable: string;
+    dataframeExportTable: string;
+    // Integration panel strings
+    integrationsTitle: string;
+    integrationsNoIntegrationsFound: string;
+    integrationsConnected: string;
+    integrationsNotConfigured: string;
+    integrationsConfigure: string;
+    integrationsReconfigure: string;
+    integrationsReset: string;
+    integrationsConfirmResetTitle: string;
+    integrationsConfirmResetMessage: string;
+    integrationsConfirmResetDetails: string;
+    integrationsConfigureTitle: string;
+    integrationsCancel: string;
+    integrationsSave: string;
+    // PostgreSQL form strings
+    integrationsPostgresNameLabel: string;
+    integrationsPostgresNamePlaceholder: string;
+    integrationsPostgresHostLabel: string;
+    integrationsPostgresHostPlaceholder: string;
+    integrationsPostgresPortLabel: string;
+    integrationsPostgresPortPlaceholder: string;
+    integrationsPostgresDatabaseLabel: string;
+    integrationsPostgresDatabasePlaceholder: string;
+    integrationsPostgresUsernameLabel: string;
+    integrationsPostgresUsernamePlaceholder: string;
+    integrationsPostgresPasswordLabel: string;
+    integrationsPostgresPasswordPlaceholder: string;
+    integrationsPostgresSslLabel: string;
+    // BigQuery form strings
+    integrationsBigQueryNameLabel: string;
+    integrationsBigQueryNamePlaceholder: string;
+    integrationsBigQueryProjectIdLabel: string;
+    integrationsBigQueryProjectIdPlaceholder: string;
+    integrationsBigQueryCredentialsLabel: string;
+    integrationsBigQueryCredentialsPlaceholder: string;
+    integrationsBigQueryCredentialsRequired: string;
+    // Common form strings
+    integrationsRequiredField: string;
+    integrationsOptionalField: string;
 };
 // Map all messages to specific payloads
 export class IInteractiveWindowMapping {

src/messageTypes.ts

@@ -0,0 +1,75 @@
+import { inject, injectable } from 'inversify';
+
+import { logger } from '../../../platform/logging';
+import { IDeepnoteNotebookManager } from '../../types';
+import { IntegrationStatus, IntegrationWithStatus } from './integrationTypes';
+import { IIntegrationDetector, IIntegrationStorage } from './types';
+import { BlockWithIntegration, scanBlocksForIntegrations } from './integrationUtils';
+
+/**
+ * Service for detecting integrations used in Deepnote notebooks
+ */
+@injectable()
+export class IntegrationDetector implements IIntegrationDetector {
+    constructor(
+        @inject(IIntegrationStorage) private readonly integrationStorage: IIntegrationStorage,
+        @inject(IDeepnoteNotebookManager) private readonly notebookManager: IDeepnoteNotebookManager
+    ) {}
+
+    /**
+     * Detect all integrations used in the given project
+     */
+    async detectIntegrations(projectId: string): Promise<Map<string, IntegrationWithStatus>> {
+        // Get the project
+        const project = this.notebookManager.getOriginalProject(projectId);
+        if (!project) {
+            logger.warn(
+                `IntegrationDetector: No project found for ID: ${projectId}. The project may not have been loaded yet.`
+            );
+            return new Map();
+        }
+
+        logger.debug(
+            `IntegrationDetector: Scanning project ${projectId} with ${project.project.notebooks.length} notebooks`
+        );
+
+        // Collect all blocks with SQL integration metadata from all notebooks
+        const blocksWithIntegrations: BlockWithIntegration[] = [];
+        for (const notebook of project.project.notebooks) {
+            logger.trace(`IntegrationDetector: Scanning notebook ${notebook.id} with ${notebook.blocks.length} blocks`);
+
+            for (const block of notebook.blocks) {
+                // Check if this is a code block with SQL integration metadata
+                if (block.type === 'code' && block.metadata?.sql_integration_id) {
+                    blocksWithIntegrations.push({
+                        id: block.id,
+                        sql_integration_id: block.metadata.sql_integration_id
+                    });
+                } else if (block.type === 'code') {
+                    logger.trace(
+                        `IntegrationDetector: Block ${block.id} has no sql_integration_id. Metadata:`,
+                        block.metadata
+                    );
+                }
+            }
+        }
+
+        // Use the shared utility to scan blocks and build the status map
+        return scanBlocksForIntegrations(blocksWithIntegrations, this.integrationStorage, 'IntegrationDetector');
+    }
+
+    /**
+     * Check if a project has any unconfigured integrations
+     */
+    async hasUnconfiguredIntegrations(projectId: string): Promise<boolean> {
+        const integrations = await this.detectIntegrations(projectId);
+
+        for (const integration of integrations.values()) {
+            if (integration.status === IntegrationStatus.Disconnected) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/notebooks/deepnote/integrations/integrationDetector.ts

@@ -0,0 +1,198 @@
+import { inject, injectable } from 'inversify';
+import { commands, l10n, NotebookDocument, window, workspace } from 'vscode';
+
+import { IExtensionContext } from '../../../platform/common/types';
+import { Commands } from '../../../platform/common/constants';
+import { logger } from '../../../platform/logging';
+import { IIntegrationDetector, IIntegrationManager, IIntegrationStorage, IIntegrationWebviewProvider } from './types';
+import { IntegrationStatus, IntegrationWithStatus } from './integrationTypes';
+import { BlockWithIntegration, scanBlocksForIntegrations } from './integrationUtils';
+
+/**
+ * Manages integration UI and commands for Deepnote notebooks
+ */
+@injectable()
+export class IntegrationManager implements IIntegrationManager {
+    private hasIntegrationsContext = 'deepnote.hasIntegrations';
+
+    private hasUnconfiguredIntegrationsContext = 'deepnote.hasUnconfiguredIntegrations';
+
+    constructor(
+        @inject(IExtensionContext) private readonly extensionContext: IExtensionContext,
+        @inject(IIntegrationDetector) private readonly integrationDetector: IIntegrationDetector,
+        @inject(IIntegrationStorage) private readonly integrationStorage: IIntegrationStorage,
+        @inject(IIntegrationWebviewProvider) private readonly webviewProvider: IIntegrationWebviewProvider
+    ) {}
+
+    public activate(): void {
+        // Register the manage integrations command
+        // The command can optionally receive an integration ID to select/configure
+        // Note: When invoked from a notebook cell status bar, VSCode passes context object first,
+        // then the actual arguments from the command definition
+        this.extensionContext.subscriptions.push(
+            commands.registerCommand(Commands.ManageIntegrations, (...args: unknown[]) => {
+                logger.debug(`IntegrationManager: Command invoked with args:`, args);
+
+                // Find the integration ID from the arguments
+                // It could be the first arg (if called directly) or in the args array (if called from UI)
+                let integrationId: string | undefined;
+
+                for (const arg of args) {
+                    if (typeof arg === 'string') {
+                        integrationId = arg;
+                        break;
+                    }
+                }
+
+                logger.debug(`IntegrationManager: Extracted integrationId: ${integrationId}`);
+                return this.showIntegrationsUI(integrationId);
+            })
+        );
+
+        // Listen for active notebook changes to update context
+        this.extensionContext.subscriptions.push(
+            window.onDidChangeActiveNotebookEditor(() =>
+                this.updateContext().catch((err) =>
+                    logger.error('IntegrationManager: Failed to update context on notebook editor change', err)
+                )
+            )
+        );
+
+        // Listen for notebook document changes
+        this.extensionContext.subscriptions.push(
+            workspace.onDidOpenNotebookDocument(() =>
+                this.updateContext().catch((err) =>
+                    logger.error('IntegrationManager: Failed to update context on notebook open', err)
+                )
+            )
+        );
+
+        this.extensionContext.subscriptions.push(
+            workspace.onDidCloseNotebookDocument(() =>
+                this.updateContext().catch((err) =>
+                    logger.error('IntegrationManager: Failed to update context on notebook close', err)
+                )
+            )
+        );
+
+        // Initial context update
+        this.updateContext().catch((err) =>
+            logger.error('IntegrationManager: Failed to update context on activation', err)
+        );
+    }
+
+    /**
+     * Update the context keys based on the active notebook
+     */
+    private async updateContext(): Promise<void> {
+        const activeNotebook = window.activeNotebookEditor?.notebook;
+
+        if (!activeNotebook || activeNotebook.notebookType !== 'deepnote') {
+            await commands.executeCommand('setContext', this.hasIntegrationsContext, false);
+            await commands.executeCommand('setContext', this.hasUnconfiguredIntegrationsContext, false);
+            return;
+        }
+
+        // Get the project ID from the notebook metadata
+        const projectId = activeNotebook.metadata?.deepnoteProjectId;
+        if (!projectId) {
+            await commands.executeCommand('setContext', this.hasIntegrationsContext, false);
+            await commands.executeCommand('setContext', this.hasUnconfiguredIntegrationsContext, false);
+            return;
+        }
+
+        // Detect integrations in the project
+        const integrations = await this.integrationDetector.detectIntegrations(projectId);
+        const hasIntegrations = integrations.size > 0;
+        const hasUnconfigured = Array.from(integrations.values()).some(
+            (integration) => integration.status === IntegrationStatus.Disconnected
+        );
+
+        await commands.executeCommand('setContext', this.hasIntegrationsContext, hasIntegrations);
+        await commands.executeCommand('setContext', this.hasUnconfiguredIntegrationsContext, hasUnconfigured);
+    }
+
+    /**
+     * Show the integrations management UI
+     * @param selectedIntegrationId Optional integration ID to select/configure immediately
+     */
+    private async showIntegrationsUI(selectedIntegrationId?: string): Promise<void> {
+        const activeNotebook = window.activeNotebookEditor?.notebook;
+
+        if (!activeNotebook || activeNotebook.notebookType !== 'deepnote') {
+            void window.showErrorMessage(l10n.t('No active Deepnote notebook'));
+            return;
+        }
+
+        const projectId = activeNotebook.metadata?.deepnoteProjectId;
+        if (!projectId) {
+            void window.showErrorMessage(l10n.t('Cannot determine project ID'));
+            return;
+        }
+
+        logger.debug(`IntegrationManager: Project ID: ${projectId}`);
+        logger.trace(`IntegrationManager: Notebook metadata:`, activeNotebook.metadata);
+
+        // First try to detect integrations from the stored project
+        let integrations = await this.integrationDetector.detectIntegrations(projectId);
+
+        // If no integrations found in stored project, scan cells directly
+        // This handles the case where the notebook was already open when the extension loaded
+        if (integrations.size === 0) {
+            logger.debug(`IntegrationManager: No integrations found in stored project, scanning cells directly`);
+            integrations = await this.detectIntegrationsFromCells(activeNotebook);
+        }
+
+        logger.debug(`IntegrationManager: Found ${integrations.size} integrations`);
+
+        // If a specific integration was requested (e.g., from status bar click),
+        // ensure it's in the map even if not detected from the project
+        if (selectedIntegrationId && !integrations.has(selectedIntegrationId)) {
+            logger.debug(`IntegrationManager: Adding requested integration ${selectedIntegrationId} to the map`);
+            const config = await this.integrationStorage.get(selectedIntegrationId);
+            integrations.set(selectedIntegrationId, {
+                config: config || null,
+                status: config ? IntegrationStatus.Connected : IntegrationStatus.Disconnected
+            });
+        }
+
+        if (integrations.size === 0) {
+            void window.showInformationMessage(l10n.t('No integrations found in this project.'));
+            return;
+        }
+
+        // Show the webview with optional selected integration
+        await this.webviewProvider.show(integrations, selectedIntegrationId);
+    }
+
+    /**
+     * Detect integrations by scanning cells directly (fallback method)
+     * This is used when the project isn't stored in the notebook manager
+     */
+    private async detectIntegrationsFromCells(notebook: NotebookDocument): Promise<Map<string, IntegrationWithStatus>> {
+        // Collect all cells with SQL integration metadata
+        const blocksWithIntegrations: BlockWithIntegration[] = [];
+
+        for (const cell of notebook.getCells()) {
+            const metadata = cell.metadata;
+            logger.trace(`IntegrationManager: Cell ${cell.index} metadata:`, metadata);
+
+            // Check cell metadata for sql_integration_id
+            if (metadata && typeof metadata === 'object') {
+                const integrationId = (metadata as Record<string, unknown>).sql_integration_id;
+                if (typeof integrationId === 'string') {
+                    logger.debug(`IntegrationManager: Found integration ${integrationId} in cell ${cell.index}`);
+                    blocksWithIntegrations.push({
+                        id: `cell-${cell.index}`,
+                        sql_integration_id: integrationId
+                    });
+                }
+            }
+        }
+
+        logger.debug(`IntegrationManager: Found ${blocksWithIntegrations.length} cells with integrations`);
+
+        // Use the shared utility to scan blocks and build the status map
+        return scanBlocksForIntegrations(blocksWithIntegrations, this.integrationStorage, 'IntegrationManager');
+    }
+}