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

package.json

@@ -115,6 +115,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,32 @@ Orchestrates the integration management UI and commands.
 3. Manager opens webview with integration list
 4. Optionally pre-selects a specific integration for configuration
 
+Both commands act only on the notebook a menu or the panel names, when one is given, and refuse it once it is closed
+rather than acting on whichever editor has focus. They also refuse a snapshot (`*.snapshot.deepnote`): it matches the
+notebook selector, but it records a past run, and the integrations writer never edits one.
+
+**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 `addProjectIntegration` (see "Project
+   files" below). 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. Refreshes the integrations panel when one is open for this project, without revealing it; run from the command
+   palette, the command never opens one. Then re-runs the integration env refresh in the project's running kernels,
+   since no storage change event fires for a roster-only edit. The panel goes first: a busy kernel answers the refresh
+   only after its running cell.
+
+The panel's Delete only takes a linked integration off the active project's roster, and keeps its credentials, while
+another project in the open workspace folders still declares the id. No storage change event fires then either, so the
+panel refreshes the project's running kernels itself. Reset, Sign out and Save go ahead on shared credentials, which
+are the same for every project declaring the id, and their success message names the other projects they affected.
+
 #### 4. **Integration Webview** (`integrationWebview.ts`)
 
 Provides the webview-based UI for managing integration credentials.
@@ -444,6 +470,17 @@ Provides the webview-based UI for managing integration credentials.
 - Configuration forms for each integration type
 - Delete/reset functionality
 
+**Project files:**
+
+Each panel action edits the roster entry it acts on, through `projectIntegrationsWriter.ts`: Save adds the saved
+integration or updates its entry in place (`addProjectIntegration`), Delete removes it (`removeProjectIntegration`),
+and Reset leaves the roster alone. Every edit merges into what each of the project's `.deepnote` files holds rather
+than writing the panel's list, so entries the panel does not list survive it: types it cannot configure, like
+`pandas-dataframe`, and integrations linked after it opened. The active file goes first, and the siblings are only
+swept once it is on disk; each open notebook's cached project then takes the list its own file now holds. A Save
+refreshes the project's running kernels once the roster holds the integration, since the refresh its credential save
+triggers may have read the roster before.
+
 **Connection Status:**
 
 `IntegrationItem.tsx` derives the status pill from two inputs: `config` (the SecretStorage credentials the panel
@@ -480,6 +517,9 @@ Extension → Webview:
 Webview → Extension:
 
 ```typescript
+// Posted on every mount, once the listener is attached; answered with the loc strings, then the list
+{ type: 'started' }
+
 // Save configuration
 { type: 'save', integrationId: string, config: IntegrationConfig }
 

specs/INTEGRATION_ENV_LIVE_REFRESH.md

@@ -42,7 +42,10 @@ Reacts to **file** changes.
 
 ### 3. `IntegrationEnvLiveRefresher` (`integrationEnvLiveRefresher.node.ts`)
 
-Performs the refresh, for both triggers.
+Performs the refresh, for both triggers above and for edits to a project's `integrations` list, which decides the
+stored configs its kernels get. Such an edit writes no storage, so no event fires and the code making it calls the
+refresher for the project's open notebooks itself: `IntegrationManager` after Add Existing Integration, and
+`IntegrationWebviewProvider` after a Save, or after a Delete that only takes a shared integration off the project.
 
 - Skips notebooks with no kernel, or whose kernel has never started
 - Runs a hidden execution in each remaining kernel:
@@ -127,7 +130,7 @@ web counterpart, since the loopback server and the file reads both require Node
 
 - `IntegrationEnvLiveRefresher.refreshNotebook()` never throws; a per-notebook failure is logged and the other
   notebooks still refresh
-- Both triggers wrap their async entry point and log rather than surfacing an unhandled rejection
+- Every trigger wraps its async entry point and logs rather than surfacing an unhandled rejection
 - A refresh that produces `error` outputs is counted as failed, so the success message only appears when at
   least one kernel actually applied the new environment
 - `UserpodApiEndpoints` keeps a persistent `error` listener (an `error` with no listener would crash the

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.
@@ -36,24 +36,22 @@ export class DeepnoteNotebookManager implements IDeepnoteNotebookManager {
         notebookEntries.set(notebookId, clonedProject);
     }
 
-    /**
-     * 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 {
+    /** Replaces the integrations list of one cached (projectId, notebookId) entry (cache-only). */
+    updateProjectIntegrationsForNotebook(
+        projectId: string,
+        notebookId: string,
+        integrations: RawProjectIntegration[]
+    ): void {
         const notebookEntries = this.originalProjects.get(projectId);
+        const project = notebookEntries?.get(notebookId);
 
-        if (!notebookEntries || notebookEntries.size === 0) {
-            return false;
+        if (!notebookEntries || !project) {
+            return;
         }
 
-        for (const [notebookId, project] of notebookEntries) {
-            const updatedProject = structuredClone(project);
-            updatedProject.project.integrations = structuredClone(integrations);
-
-            notebookEntries.set(notebookId, updatedProject);
-        }
+        const updatedProject = structuredClone(project);
+        updatedProject.project.integrations = structuredClone(integrations);
 
-        return true;
+        notebookEntries.set(notebookId, updatedProject);
     }
 }

src/notebooks/deepnote/deepnoteNotebookManager.unit.test.ts

@@ -52,91 +52,33 @@ suite('DeepnoteNotebookManager', () => {
         });
     });
 
-    suite('updateProjectIntegrations', () => {
-        test('should update integrations list for existing project and return true', () => {
-            manager.storeOriginalProject('project-123', 'notebook-456', mockProject);
-
-            const integrations: ProjectIntegration[] = [
-                { id: 'int-1', name: 'PostgreSQL', type: 'pgsql' },
-                { id: 'int-2', name: 'BigQuery', type: 'big-query' }
-            ];
-
-            const result = manager.updateProjectIntegrations('project-123', integrations);
-
-            assert.strictEqual(result, true);
-
-            const updatedProject = manager.getProjectForNotebook('project-123', 'notebook-456');
-            assert.deepStrictEqual(updatedProject?.project.integrations, integrations);
-        });
-
-        test('should replace existing integrations list and return true', () => {
-            const projectWithIntegrations: DeepnoteFile = {
+    suite('updateProjectIntegrationsForNotebook', () => {
+        test('replaces the list of the entry and keeps every other field of it', () => {
+            manager.storeOriginalProject('project-123', 'notebook-456', {
                 ...mockProject,
-                project: {
-                    ...mockProject.project,
-                    integrations: [{ id: 'old-int', name: 'Old Integration', type: 'pgsql' }]
-                }
-            };
-
-            manager.storeOriginalProject('project-123', 'notebook-456', projectWithIntegrations);
-
-            const newIntegrations: ProjectIntegration[] = [
-                { id: 'new-int-1', name: 'New Integration 1', type: 'pgsql' },
-                { id: 'new-int-2', name: 'New Integration 2', type: 'big-query' }
-            ];
-
-            const result = manager.updateProjectIntegrations('project-123', newIntegrations);
+                project: { ...mockProject.project, integrations: [{ id: 'old-int', name: 'Old', type: 'pgsql' }] }
+            });
 
-            assert.strictEqual(result, true);
+            const integrations: ProjectIntegration[] = [{ id: 'int-1', name: 'PostgreSQL', type: 'pgsql' }];
 
-            const updatedProject = manager.getProjectForNotebook('project-123', 'notebook-456');
-            assert.deepStrictEqual(updatedProject?.project.integrations, newIntegrations);
-        });
+            manager.updateProjectIntegrationsForNotebook('project-123', 'notebook-456', integrations);
 
-        test('should handle empty integrations array and return true', () => {
-            const projectWithIntegrations: DeepnoteFile = {
+            assert.deepStrictEqual(manager.getProjectForNotebook('project-123', 'notebook-456'), {
                 ...mockProject,
-                project: {
-                    ...mockProject.project,
-                    integrations: [{ id: 'int-1', name: 'Integration 1', type: 'pgsql' }]
-                }
-            };
-
-            manager.storeOriginalProject('project-123', 'notebook-456', projectWithIntegrations);
-
-            const result = manager.updateProjectIntegrations('project-123', []);
-
-            assert.strictEqual(result, true);
-
-            const updatedProject = manager.getProjectForNotebook('project-123', 'notebook-456');
-            assert.deepStrictEqual(updatedProject?.project.integrations, []);
-        });
-
-        test('should return false for unknown project', () => {
-            const result = manager.updateProjectIntegrations('unknown-project', [
-                { id: 'int-1', name: 'Integration', type: 'pgsql' }
-            ]);
-
-            assert.strictEqual(result, false);
-
-            const project = manager.getProjectForNotebook('unknown-project', 'notebook-456');
-            assert.strictEqual(project, undefined);
+                project: { ...mockProject.project, integrations }
+            });
         });
 
-        test('should preserve other project properties and return true', () => {
+        test('caches nothing for a project or notebook that is not cached', () => {
             manager.storeOriginalProject('project-123', 'notebook-456', mockProject);
-
             const integrations: ProjectIntegration[] = [{ id: 'int-1', name: 'PostgreSQL', type: 'pgsql' }];
 
-            const result = manager.updateProjectIntegrations('project-123', integrations);
+            manager.updateProjectIntegrationsForNotebook('unknown-project', 'notebook-456', integrations);
+            manager.updateProjectIntegrationsForNotebook('project-123', 'unknown-notebook', integrations);
 
-            assert.strictEqual(result, true);
-
-            const updatedProject = manager.getProjectForNotebook('project-123', 'notebook-456');
-            assert.strictEqual(updatedProject?.project.id, mockProject.project.id);
-            assert.strictEqual(updatedProject?.project.name, mockProject.project.name);
-            assert.strictEqual(updatedProject?.version, mockProject.version);
-            assert.deepStrictEqual(updatedProject?.metadata, mockProject.metadata);
+            assert.strictEqual(manager.getProjectForNotebook('unknown-project', 'notebook-456'), undefined);
+            assert.strictEqual(manager.getProjectForNotebook('project-123', 'unknown-notebook'), undefined);
+            assert.deepStrictEqual(manager.getProjectForNotebook('project-123', 'notebook-456'), mockProject);
         });
     });
 
@@ -180,42 +122,38 @@ suite('DeepnoteNotebookManager', () => {
             assert.strictEqual(result, undefined);
         });
 
-        test('updateProjectIntegrations updates every cached notebook entry under the project', () => {
+        test('updateProjectIntegrationsForNotebook updates that entry alone, leaving the siblings on their own lists', () => {
+            const siblingIntegrations: ProjectIntegration[] = [{ id: 'int-b', name: 'MySQL', type: 'mysql' }];
+            const projectB = siblingProject(nbB, 'Sibling B');
+            projectB.project.integrations = siblingIntegrations;
             manager.storeOriginalProject(projectId, nbA, siblingProject(nbA, 'Sibling A'));
-            manager.storeOriginalProject(projectId, nbB, siblingProject(nbB, 'Sibling B'));
+            manager.storeOriginalProject(projectId, nbB, projectB);
 
-            const integrations: ProjectIntegration[] = [
-                { id: 'int-1', name: 'PostgreSQL', type: 'pgsql' },
-                { id: 'int-2', name: 'BigQuery', type: 'big-query' }
-            ];
+            const integrations: ProjectIntegration[] = [{ id: 'int-1', name: 'PostgreSQL', type: 'pgsql' }];
 
-            const updated = manager.updateProjectIntegrations(projectId, integrations);
+            manager.updateProjectIntegrationsForNotebook(projectId, nbA, integrations);
 
-            assert.strictEqual(updated, true);
-            // BOTH siblings of the project must see the new integrations.
             assert.deepStrictEqual(manager.getProjectForNotebook(projectId, nbA)?.project.integrations, integrations);
-            assert.deepStrictEqual(manager.getProjectForNotebook(projectId, nbB)?.project.integrations, integrations);
+            assert.deepStrictEqual(
+                manager.getProjectForNotebook(projectId, nbB)?.project.integrations,
+                siblingIntegrations
+            );
         });
 
-        test('updateProjectIntegrations deep-clones integrations so cached siblings are isolated from the caller and each other', () => {
+        test('updateProjectIntegrationsForNotebook deep-clones integrations so the cache is isolated from the caller', () => {
             manager.storeOriginalProject(projectId, nbA, siblingProject(nbA, 'Sibling A'));
-            manager.storeOriginalProject(projectId, nbB, siblingProject(nbB, 'Sibling B'));
 
             const pg: ProjectIntegration = { id: 'int-1', name: 'PostgreSQL', type: 'pgsql' };
             const integrations: ProjectIntegration[] = [pg];
 
-            manager.updateProjectIntegrations(projectId, integrations);
+            manager.updateProjectIntegrationsForNotebook(projectId, nbA, integrations);
 
-            // Mutating the caller-owned array and its contents after the call must not leak into the cache.
             pg.name = 'MUTATED';
             integrations.push({ id: 'int-2', name: 'BigQuery', type: 'big-query' });
 
-            const cachedA = manager.getProjectForNotebook(projectId, nbA)?.project.integrations;
-            const cachedB = manager.getProjectForNotebook(projectId, nbB)?.project.integrations;
-
-            assert.deepStrictEqual(cachedA, [{ id: 'int-1', name: 'PostgreSQL', type: 'pgsql' }]);
-            // Each sibling holds its own array instance rather than a shared reference.
-            assert.notStrictEqual(cachedA, cachedB);
+            assert.deepStrictEqual(manager.getProjectForNotebook(projectId, nbA)?.project.integrations, [
+                { id: 'int-1', name: 'PostgreSQL', type: 'pgsql' }
+            ]);
         });
     });
 });