feat(deepnote-file): Migration to single notebook deepnote file

build/mocha-esm-loader.js

@@ -335,6 +335,7 @@ export async function load(url, context, nextLoad) {
                 export const EndOfLine = createClassProxy('EndOfLine');
                 export const PortAutoForwardAction = createClassProxy('PortAutoForwardAction');
                 export const PortAttributes = createClassProxy('PortAttributes');
+                export const TabInputNotebook = createClassProxy('TabInputNotebook');
             `,
                 shortCircuit: true
             };

package.json

@@ -93,6 +93,12 @@
                 "category": "Deepnote",
                 "icon": "$(reveal)"
             },
+            {
+                "command": "deepnote.copyNotebookDetails",
+                "title": "%deepnote.commands.copyNotebookDetails.title%",
+                "category": "Deepnote",
+                "icon": "$(copy)"
+            },
             {
                 "command": "deepnote.enableSnapshots",
                 "title": "%deepnote.commands.enableSnapshots.title%",

package.nls.json

@@ -250,6 +250,7 @@
     "deepnote.commands.openNotebook.title": "Open Notebook",
     "deepnote.commands.openFile.title": "Open File",
     "deepnote.commands.revealInExplorer.title": "Reveal in Explorer",
+    "deepnote.commands.copyNotebookDetails.title": "Copy Active Deepnote Notebook Details",
     "deepnote.commands.enableSnapshots.title": "Enable Snapshots",
     "deepnote.commands.disableSnapshots.title": "Disable Snapshots",
     "deepnote.commands.manageIntegrations.title": "Manage Integrations",

src/kernels/deepnote/deepnoteServerStarter.node.ts

@@ -280,7 +280,7 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
 
             throw new DeepnoteServerStartupError(
                 interpreter.uri.fsPath,
-                serverInfo?.jupyterPort ?? 0,
+                0,
                 'unknown',
                 capturedOutput?.stdout || '',
                 capturedOutput?.stderr || '',
@@ -343,11 +343,7 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
 
         this.serverOutputByFile.delete(fileKey);
 
-        const disposables = this.disposablesByFile.get(fileKey);
-        if (disposables) {
-            disposables.forEach((d) => d.dispose());
-            this.disposablesByFile.delete(fileKey);
-        }
+        this.disposeOutputListeners(fileKey);
     }
 
     /**
@@ -402,6 +398,7 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
      */
     private monitorServerOutput(fileKey: string, serverInfo: DeepnoteServerInfo): void {
         const proc = serverInfo.process;
+        this.disposeOutputListeners(fileKey);
         const disposables: IDisposable[] = [];
         this.disposablesByFile.set(fileKey, disposables);
 
@@ -446,6 +443,22 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
         }
     }
 
+    /**
+     * Dispose all output listeners registered for a given file key.
+     * Per-listener try/catch ensures one failure doesn't prevent others from being disposed.
+     */
+    private disposeOutputListeners(fileKey: string): void {
+        const disposables = this.disposablesByFile.get(fileKey) ?? [];
+        for (const d of disposables) {
+            try {
+                d.dispose();
+            } catch (ex) {
+                logger.warn(`Error disposing output listener for ${fileKey}`, ex);
+            }
+        }
+        this.disposablesByFile.delete(fileKey);
+    }
+
     public async dispose(): Promise<void> {
         logger.info('Disposing DeepnoteServerStarter - stopping all servers...');
 
@@ -485,12 +498,9 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
             await this.deleteLockFile(pid);
         }
 
-        for (const [fileKey, disposables] of this.disposablesByFile.entries()) {
-            try {
-                disposables.forEach((d) => d.dispose());
-            } catch (ex) {
-                logger.error(`Error disposing resources for ${fileKey}`, ex);
-            }
+        // Snapshot the keys first: disposeOutputListeners mutates disposablesByFile via .delete().
+        for (const fileKey of Array.from(this.disposablesByFile.keys())) {
+            this.disposeOutputListeners(fileKey);
         }
 
         this.disposablesByFile.clear();

src/kernels/deepnote/deepnoteTestHelpers.node.ts

@@ -5,11 +5,66 @@ import type { ChildProcess } from 'node:child_process';
  * Satisfies the ChildProcess interface with minimal stub values.
  */
 export function createMockChildProcess(overrides?: Partial<ChildProcess>): ChildProcess {
-    return {
+    const mockProcess: ChildProcess = {
         pid: undefined,
+        stdio: [null, null, null, null, null],
+        stdin: null,
         stdout: null,
         stderr: null,
         exitCode: null,
+        killed: false,
+        connected: false,
+        signalCode: null,
+        spawnargs: [],
+        spawnfile: '',
+        kill: () => true,
+        send: () => true,
+        disconnect: () => true,
+        unref: () => true,
+        ref: () => true,
+        addListener: function () {
+            return this;
+        },
+        emit: () => true,
+        on: function () {
+            return this;
+        },
+        once: function () {
+            return this;
+        },
+        removeListener: function () {
+            return this;
+        },
+        removeAllListeners: function () {
+            return this;
+        },
+        prependListener: function () {
+            return this;
+        },
+        prependOnceListener: function () {
+            return this;
+        },
+        [Symbol.dispose]: () => {
+            return undefined;
+        },
+        off: function () {
+            return this;
+        },
+        setMaxListeners: function () {
+            return this;
+        },
+        getMaxListeners: () => 10,
+        listeners: function () {
+            return [];
+        },
+        rawListeners: function () {
+            return [];
+        },
+        eventNames: function () {
+            return [];
+        },
+        listenerCount: () => 0,
         ...overrides
-    } as ChildProcess;
+    };
+    return mockProcess;
 }

src/notebooks/deepnote/deepnoteActivationService.ts

@@ -1,14 +1,16 @@
+import { deserializeDeepnoteFile } from '@deepnote/blocks';
 import { inject, injectable, optional } from 'inversify';
-import { commands, l10n, workspace, window, type Disposable, type NotebookDocumentContentOptions } from 'vscode';
+import { commands, l10n, window, workspace, type Disposable, type NotebookDocumentContentOptions } from 'vscode';
 
 import { IExtensionSyncActivationService } from '../../platform/activation/types';
 import { IExtensionContext } from '../../platform/common/types';
 import { ILogger } from '../../platform/logging/types';
 import { IDeepnoteNotebookManager } from '../types';
-import { DeepnoteNotebookSerializer } from './deepnoteSerializer';
+import { DeepnoteAutoSplitter } from './deepnoteAutoSplitter';
 import { DeepnoteExplorerView } from './deepnoteExplorerView';
-import { IIntegrationManager } from './integrations/types';
 import { DeepnoteInputBlockEditProtection } from './deepnoteInputBlockEditProtection';
+import { DeepnoteNotebookSerializer } from './deepnoteSerializer';
+import { IIntegrationManager } from './integrations/types';
 import { SnapshotService } from './snapshots/snapshotService';
 
 /**
@@ -17,6 +19,8 @@ import { SnapshotService } from './snapshots/snapshotService';
  */
 @injectable()
 export class DeepnoteActivationService implements IExtensionSyncActivationService {
+    private autoSplitter: DeepnoteAutoSplitter;
+
     private editProtection: DeepnoteInputBlockEditProtection;
 
     private explorerView: DeepnoteExplorerView;
@@ -44,13 +48,19 @@ export class DeepnoteActivationService implements IExtensionSyncActivationServic
      * Called during extension activation to set up Deepnote integration.
      */
     public activate() {
+        this.autoSplitter = new DeepnoteAutoSplitter();
         this.serializer = new DeepnoteNotebookSerializer(this.notebookManager, this.snapshotService);
-        this.explorerView = new DeepnoteExplorerView(this.extensionContext, this.notebookManager, this.logger);
+        this.explorerView = new DeepnoteExplorerView(this.extensionContext, this.logger);
         this.editProtection = new DeepnoteInputBlockEditProtection(this.logger);
         this.snapshotsEnabled = this.isSnapshotsEnabled();
 
         this.registerSerializer();
         this.extensionContext.subscriptions.push(this.editProtection);
+        this.extensionContext.subscriptions.push(
+            workspace.onDidOpenNotebookDocument((doc) => {
+                void this.checkAndSplitIfNeeded(doc);
+            })
+        );
         this.extensionContext.subscriptions.push(
             workspace.onDidChangeConfiguration((event) => {
                 if (event.affectsConfiguration('deepnote.snapshots.enabled')) {
@@ -70,6 +80,25 @@ export class DeepnoteActivationService implements IExtensionSyncActivationServic
         this.integrationManager.activate();
     }
 
+    private async checkAndSplitIfNeeded(doc: import('vscode').NotebookDocument): Promise<void> {
+        if (doc.notebookType !== 'deepnote') {
+            return;
+        }
+
+        try {
+            const fileUri = doc.uri;
+            const content = await workspace.fs.readFile(fileUri);
+            const deepnoteFile = deserializeDeepnoteFile(new TextDecoder().decode(content));
+            const result = await this.autoSplitter.splitIfNeeded(fileUri, deepnoteFile);
+
+            if (result.wasSplit) {
+                this.explorerView.refreshTree();
+            }
+        } catch (error) {
+            this.logger.error('Failed to check/split notebook file', error);
+        }
+    }
+
     private isSnapshotsEnabled(): boolean {
         if (this.snapshotService) {
             return this.snapshotService.isSnapshotsEnabled();