feat(integrations): add an "Add Existing Integration" picker to reuse integrations across projects

package.json

@@ -150,6 +150,12 @@
                 "category": "Deepnote",
                 "icon": "$(plug)"
             },
+            {
+                "command": "deepnote.addExistingIntegration",
+                "title": "%deepnote.commands.addExistingIntegration.title%",
+                "category": "Deepnote",
+                "icon": "$(link)"
+            },
             {
                 "command": "deepnote.authenticateIntegration",
                 "title": "%deepnote.commands.authenticateIntegration.title%",

package.nls.json

@@ -257,6 +257,7 @@
     "deepnote.commands.enableSnapshots.title": "Enable Snapshots",
     "deepnote.commands.disableSnapshots.title": "Disable Snapshots",
     "deepnote.commands.manageIntegrations.title": "Manage Integrations",
+    "deepnote.commands.addExistingIntegration.title": "Add Existing Integration",
     "deepnote.commands.authenticateIntegration.title": "Authenticate Integration",
     "deepnote.commands.newProject.title": "New Project",
     "deepnote.commands.importNotebook.title": "Import Notebook",

specs/INTEGRATIONS_CREDENTIALS.md

@@ -433,6 +433,20 @@ Orchestrates the integration management UI and commands.
 3. Manager opens webview with integration list
 4. Optionally pre-selects a specific integration for configuration
 
+**Add Existing Integration** (`deepnote.addExistingIntegration`, also the "Add Existing Integration" button in the
+webview, implemented in `existingIntegrationPicker.ts`):
+
+1. Scans every `.deepnote` file in the workspace folders (snapshots excluded) and collects the roster entries of
+   _other_ projects whose id has a config in SecretStorage; ids already on the active project's roster are skipped,
+   as are file-only (`.deepnote.env.yaml`) integrations, which already apply workspace-wide.
+2. Shows a QuickPick (name, type, "Used in: <projects>"). An id whose roster type disagrees with the stored config's
+   type is dropped with a warning rather than offered.
+3. On selection, appends `{ id, name, type }` to the active project's roster via `persistProjectIntegrations`.
+   Nothing is copied in SecretStorage: configs (and federated refresh tokens) are keyed by integration id alone, and
+   the roster entry is what scopes an integration to a project, so the linked project resolves the same credentials.
+4. Re-runs the integration env refresh in the project's running kernels and re-shows the panel, since no storage
+   change event fires for a roster-only edit.
+
 #### 4. **Integration Webview** (`integrationWebview.ts`)
 
 Provides the webview-based UI for managing integration credentials.

src/messageTypes.ts

@@ -10,6 +10,7 @@ import {
 import { KernelSocketOptions } from './kernels/types';
 import { IJupyterVariable, IJupyterVariablesRequest, IJupyterVariablesResponse } from './kernels/variables/types';
 import { WidgetScriptSource } from './notebooks/controllers/ipywidgets/types';
+import type { IntegrationTypeLabelKey } from './platform/notebooks/deepnote/integrationTypeLabels';
 
 export type NotifyIPyWidgetWidgetVersionNotSupportedAction = {
     moduleName: 'qgrid';
@@ -120,7 +121,7 @@ export enum SharedMessages {
     LocInit = 'loc_init'
 }
 
-export type LocalizedMessages = {
+export type LocalizedMessages = { [K in IntegrationTypeLabelKey]: string } & {
     collapseSingle: string;
     expandSingle: string;
     openExportFileYes: string;
@@ -186,29 +187,10 @@ export type LocalizedMessages = {
     integrationsCancel: string;
     integrationsSave: string;
     integrationsAddNewIntegration: string;
+    integrationsAddExistingIntegration: string;
     integrationsDatabase: string;
     integrationsDataWarehousesLakes: string;
     integrationsDatabases: string;
-    // Integration type labels
-    integrationsPostgresTypeLabel: string;
-    integrationsBigQueryTypeLabel: string;
-    integrationsSnowflakeTypeLabel: string;
-    integrationsAlloyDBTypeLabel: string;
-    integrationsAthenaTypeLabel: string;
-    integrationsClickHouseTypeLabel: string;
-    integrationsCloudSqlTypeLabel: string;
-    integrationsDatabricksTypeLabel: string;
-    integrationsDremioTypeLabel: string;
-    integrationsMariaDBTypeLabel: string;
-    integrationsMaterializeTypeLabel: string;
-    integrationsMindsDBTypeLabel: string;
-    integrationsMongoDBTypeLabel: string;
-    integrationsMySQLTypeLabel: string;
-    integrationsDuckDBTypeLabel: string;
-    integrationsRedshiftTypeLabel: string;
-    integrationsSpannerTypeLabel: string;
-    integrationsSQLServerTypeLabel: string;
-    integrationsTrinoTypeLabel: string;
     // PostgreSQL form strings
     integrationsPostgresNameLabel: string;
     integrationsPostgresNamePlaceholder: string;

src/notebooks/deepnote/deepnoteNotebookManager.ts

@@ -1,7 +1,7 @@
 import { injectable } from 'inversify';
 import type { DeepnoteFile } from '@deepnote/blocks';
 
-import { IDeepnoteNotebookManager, ProjectIntegration } from '../types';
+import { IDeepnoteNotebookManager, RawProjectIntegration } from '../types';
 
 /**
  * Centralized manager for tracking Deepnote notebook selections and project state.
@@ -40,7 +40,7 @@ export class DeepnoteNotebookManager implements IDeepnoteNotebookManager {
      * Updates the integrations list across every cached notebook entry under the project (cache-only).
      * @returns `true` if at least one cached entry was updated, `false` otherwise.
      */
-    updateProjectIntegrations(projectId: string, integrations: ProjectIntegration[]): boolean {
+    updateProjectIntegrations(projectId: string, integrations: RawProjectIntegration[]): boolean {
         const notebookEntries = this.originalProjects.get(projectId);
 
         if (!notebookEntries || notebookEntries.size === 0) {

src/notebooks/deepnote/integrations/existingIntegrationPicker.ts

@@ -0,0 +1,182 @@
+import { CancellationToken, RelativePattern, Uri, workspace } from 'vscode';
+
+import { readDeepnoteProjectFile } from '../../../platform/deepnote/deepnoteProjectFileReader';
+import { logger } from '../../../platform/logging';
+import {
+    ConfigurableDatabaseIntegrationType,
+    isConfigurableDatabaseIntegrationType
+} from '../../../platform/notebooks/deepnote/integrationTypes';
+import { IDeepnoteNotebookManager, ProjectIntegration, RawProjectIntegration } from '../../types';
+import { isSnapshotFile } from '../snapshots/snapshotFiles';
+import { PersistIntegrationsResult, persistProjectIntegrations } from './projectIntegrationsWriter';
+import { IIntegrationStorage } from './types';
+
+/** An integration another project in the workspace has credentials stored for, so linking it needs no re-entry. */
+export interface ReusableIntegration {
+    id: string;
+    /** Name from the stored config — the same source the panel writes to the project integrations on save. */
+    name: string;
+    /** The other projects declaring this integration; deduped and sorted. */
+    projectNames: string[];
+    type: ConfigurableDatabaseIntegrationType;
+}
+
+export interface CollectReusableIntegrationsParams {
+    /** Ids the current project already declares. */
+    excludeIntegrationIds: ReadonlySet<string>;
+    integrationStorage: IIntegrationStorage;
+    /** The project being extended; its own `.deepnote` files are skipped. */
+    projectId: string;
+    /** Stops the scan; the partial result is only fit to be discarded. */
+    token?: CancellationToken;
+}
+
+export interface CollectReusableIntegrationsResult {
+    /** The scan stopped early, so the other two fields are partial and must not be written anywhere. */
+    cancelled: boolean;
+    /**
+     * Ids skipped because some project declares a type the stored config disagrees with: linking one would put a
+     * type on this project that the credentials cannot back.
+     */
+    conflictingIds: string[];
+    integrations: ReusableIntegration[];
+}
+
+export interface AttachExistingIntegrationParams {
+    activeFileUri: Uri;
+    /** The project's full integration list: every entry is written back verbatim, so a filtered array drops entries. */
+    currentIntegrations: readonly RawProjectIntegration[];
+    integration: ReusableIntegration;
+    notebookManager: IDeepnoteNotebookManager;
+    projectId: string;
+}
+
+/**
+ * Scans every `.deepnote` file in the open workspace folders for integrations other projects declare.
+ *
+ * Reuse is a link, not a copy: `IntegrationStorage` and `FederatedAuthTokenStorage` both key configs by integration
+ * id alone, so the project's own entry is the only thing that scopes an integration to a project.
+ *
+ * Integrations configured only in `.deepnote.env.yaml` are not offered: that file already applies to every project
+ * under it, and the panel cannot write that layer.
+ */
+export async function collectReusableIntegrations(
+    params: CollectReusableIntegrationsParams
+): Promise<CollectReusableIntegrationsResult> {
+    const { excludeIntegrationIds, integrationStorage, projectId, token } = params;
+
+    const candidates = new Map<string, ReusableIntegration & { projectNameSet: Set<string> }>();
+    const conflictingIds = new Set<string>();
+    const visited = new Set<string>();
+
+    for (const workspaceFolder of workspace.workspaceFolders || []) {
+        if (token?.isCancellationRequested) {
+            return { cancelled: true, conflictingIds: [], integrations: [] };
+        }
+
+        let files: Uri[];
+
+        try {
+            files = await workspace.findFiles(
+                new RelativePattern(workspaceFolder, '**/*.deepnote'),
+                undefined,
+                undefined,
+                token
+            );
+        } catch (error) {
+            logger.error('collectReusableIntegrations: failed to enumerate .deepnote files', error);
+
+            continue;
+        }
+
+        for (const fileUri of files) {
+            if (token?.isCancellationRequested) {
+                return { cancelled: true, conflictingIds: [], integrations: [] };
+            }
+
+            const key = fileUri.toString();
+
+            if (visited.has(key) || isSnapshotFile(fileUri)) {
+                continue;
+            }
+
+            visited.add(key);
+
+            // One unreadable file must not hide every other project's integrations.
+            try {
+                const projectData = await readDeepnoteProjectFile(fileUri);
+
+                if (!projectData?.project || projectData.project.id === projectId) {
+                    continue;
+                }
+
+                const projectName = projectData.project.name || projectData.project.id;
+
+                for (const entry of projectData.project.integrations ?? []) {
+                    if (excludeIntegrationIds.has(entry.id) || !isConfigurableDatabaseIntegrationType(entry.type)) {
+                        continue;
+                    }
+
+                    const storedConfig = await integrationStorage.getIntegrationConfig(entry.id);
+
+                    if (!storedConfig) {
+                        // File-only or never configured — no stored credentials to reuse.
+                        continue;
+                    }
+
+                    if (storedConfig.type !== entry.type) {
+                        logger.warn(
+                            `collectReusableIntegrations: ${entry.id} is declared as ${entry.type} in ${fileUri.path} but stored as ${storedConfig.type}; skipping`
+                        );
+                        conflictingIds.add(entry.id);
+
+                        continue;
+                    }
+
+                    const existing = candidates.get(entry.id);
+
+                    if (existing) {
+                        existing.projectNameSet.add(projectName);
+                    } else {
+                        candidates.set(entry.id, {
+                            id: entry.id,
+                            name: storedConfig.name || entry.name || entry.id,
+                            projectNameSet: new Set([projectName]),
+                            projectNames: [],
+                            type: storedConfig.type
+                        });
+                    }
+                }
+            } catch (error) {
+                logger.error(`collectReusableIntegrations: failed to read ${fileUri.path}`, error);
+            }
+        }
+    }
+
+    // A conflict in any project disqualifies the id everywhere: the stored config is the single shared truth.
+    for (const id of conflictingIds) {
+        candidates.delete(id);
+    }
+
+    const integrations = Array.from(candidates.values())
+        .map(({ projectNameSet, ...candidate }) => ({
+            ...candidate,
+            projectNames: Array.from(projectNameSet).sort((a, b) => a.localeCompare(b))
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+
+    return { cancelled: false, conflictingIds: Array.from(conflictingIds).sort(), integrations };
+}
+
+/**
+ * Links `integration` into the project's integrations through the same writer the panel uses, so the cache, the active
+ * file and every sibling `.deepnote` file are updated together. Re-linking an id already there replaces its entry.
+ */
+export function attachExistingIntegration(params: AttachExistingIntegrationParams): Promise<PersistIntegrationsResult> {
+    const { activeFileUri, currentIntegrations, integration, notebookManager, projectId } = params;
+
+    const linked: ProjectIntegration = { id: integration.id, name: integration.name, type: integration.type };
+    const integrations = [...currentIntegrations.filter((entry) => entry.id !== integration.id), linked];
+
+    return persistProjectIntegrations({ activeFileUri, integrations, notebookManager, projectId });
+}