fix: Fix deepnote notebook deserializer and file change watcher

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 || '',
@@ -402,6 +402,16 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
      */
     private monitorServerOutput(fileKey: string, serverInfo: DeepnoteServerInfo): void {
         const proc = serverInfo.process;
+        const existing = this.disposablesByFile.get(fileKey);
+        if (existing) {
+            for (const d of existing) {
+                try {
+                    d.dispose();
+                } catch (ex) {
+                    logger.warn(`Error disposing listener for ${fileKey}`, ex);
+                }
+            }
+        }
         const disposables: IDisposable[] = [];
         this.disposablesByFile.set(fileKey, disposables);
 

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/deepnoteExplorerView.ts

@@ -260,7 +260,7 @@ export class DeepnoteExplorerView {
             await this.treeDataProvider.refreshNotebook(treeItem.context.projectId);
 
             // Optionally open the duplicated notebook
-            this.manager.selectNotebookForProject(treeItem.context.projectId, newNotebook.id);
+            this.registerNotebookOpenIntent(treeItem.context.projectId, newNotebook.id);
             const notebookUri = fileUri.with({ query: `notebook=${newNotebook.id}` });
             const document = await workspace.openNotebookDocument(notebookUri);
             await window.showNotebookDocument(document, {
@@ -508,7 +508,7 @@ export class DeepnoteExplorerView {
         await this.treeDataProvider.refreshNotebook(projectData.project.id);
 
         // Open the new notebook
-        this.manager.selectNotebookForProject(projectData.project.id, notebookId);
+        this.registerNotebookOpenIntent(projectData.project.id, notebookId);
         const notebookUri = fileUri.with({ query: `notebook=${notebookId}` });
         const document = await workspace.openNotebookDocument(notebookUri);
         await window.showNotebookDocument(document, {
@@ -517,6 +517,11 @@ export class DeepnoteExplorerView {
         });
     }
 
+    private registerNotebookOpenIntent(projectId: string, notebookId: string): void {
+        this.manager.queueNotebookResolution(projectId, notebookId);
+        this.manager.selectNotebookForProject(projectId, notebookId);
+    }
+
     private refreshExplorer(): void {
         this.treeDataProvider.refresh();
     }
@@ -537,7 +542,7 @@ export class DeepnoteExplorerView {
 
             console.log(`Selecting notebook in manager.`);
 
-            this.manager.selectNotebookForProject(context.projectId, context.notebookId);
+            this.registerNotebookOpenIntent(context.projectId, context.notebookId);
 
             console.log(`Opening notebook document.`, fileUri);
 
@@ -701,7 +706,7 @@ export class DeepnoteExplorerView {
 
             this.treeDataProvider.refresh();
 
-            this.manager.selectNotebookForProject(projectId, notebookId);
+            this.registerNotebookOpenIntent(projectId, notebookId);
 
             const notebookUri = fileUri.with({ query: `notebook=${notebookId}` });
             const document = await workspace.openNotebookDocument(notebookUri);

src/notebooks/deepnote/deepnoteFileChangeWatcher.ts

@@ -1,3 +1,5 @@
+import type { DeepnoteBlock } from '@deepnote/blocks';
+import { inject, injectable, optional } from 'inversify';
 import {
     CancellationTokenSource,
     NotebookCell,
@@ -10,13 +12,11 @@ import {
     WorkspaceEdit,
     workspace
 } from 'vscode';
-import { inject, injectable, optional } from 'inversify';
-import type { DeepnoteBlock } from '@deepnote/blocks';
 
-import { IControllerRegistration } from '../controllers/types';
 import { IExtensionSyncActivationService } from '../../platform/activation/types';
 import { IDisposableRegistry } from '../../platform/common/types';
 import { logger } from '../../platform/logging';
+import { IControllerRegistration } from '../controllers/types';
 import { IDeepnoteNotebookManager } from '../types';
 import { DeepnoteDataConverter } from './deepnoteDataConverter';
 import { DeepnoteNotebookSerializer } from './deepnoteSerializer';
@@ -99,6 +99,15 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
         this.disposables.push(watcher.onDidCreate((uri) => this.handleFileChange(uri)));
         this.disposables.push({ dispose: () => this.clearAllTimers() });
 
+        this.disposables.push(
+            workspace.onDidSaveNotebookDocument((notebook) => {
+                if (notebook.notebookType === 'deepnote') {
+                    const fileUri = notebook.uri.with({ query: '', fragment: '' });
+                    this.markSelfWrite(fileUri);
+                }
+            })
+        );
+
         if (this.snapshotService) {
             this.disposables.push(
                 this.snapshotService.onFileWritten((uri) => {
@@ -122,6 +131,13 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
         }
     }
 
+    public async applyNotebookEdits(uri: Uri, edits: NotebookEdit[]): Promise<boolean> {
+        const wsEdit = new WorkspaceEdit();
+        wsEdit.set(uri, edits);
+
+        return workspace.applyEdit(wsEdit);
+    }
+
     private clearAllTimers(): void {
         for (const timer of this.debounceTimers.values()) {
             clearTimeout(timer);
@@ -145,7 +161,7 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
      * Consumes a self-write marker. Returns true if the fs event was self-triggered.
      */
     private consumeSelfWrite(uri: Uri): boolean {
-        const key = uri.toString();
+        const key = this.normalizeFileUri(uri);
 
         // Check snapshot self-writes first
         if (this.snapshotSelfWriteUris.has(key)) {
@@ -187,6 +203,7 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
         if (liveCells.length !== newCells.length) {
             return true;
         }
+
         return liveCells.some(
             (live, i) =>
                 live.kind !== newCells[i].kind ||
@@ -275,10 +292,15 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
             return;
         }
 
+        // Pass the notebook ID explicitly to avoid mutating the global selection state.
+        // Multiple notebooks from the same project may be open simultaneously, and
+        // mutating selectedNotebookByProject would cause race conditions.
+        const targetNotebookId = notebook.metadata?.deepnoteNotebookId as string | undefined;
+
         const tokenSource = new CancellationTokenSource();
         let newData;
         try {
-            newData = await this.serializer.deserializeNotebook(content, tokenSource.token);
+            newData = await this.serializer.deserializeNotebook(content, tokenSource.token, targetNotebookId);
         } catch (error) {
             logger.warn(`[FileChangeWatcher] Failed to parse changed file: ${fileUri.path}`, error);
             return;
@@ -332,22 +354,53 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
             }
         }
 
-        const wsEdit = new WorkspaceEdit();
-        wsEdit.set(notebook.uri, edits);
-        const applied = await workspace.applyEdit(wsEdit);
+        // Apply the edit to update in-memory cells immediately (responsive UX).
+        const applied = await this.applyNotebookEdits(notebook.uri, edits);
 
         if (!applied) {
             logger.warn(`[FileChangeWatcher] Failed to apply edit: ${notebook.uri.path}`);
             return;
         }
 
-        // Save to sync mtime — mark as self-write first
-        this.markSelfWrite(notebook.uri);
+        // Serialize the notebook and write canonical bytes to disk. This ensures
+        // the file on disk matches what VS Code's serializer would produce.
+        // Then save via workspace.save() to clear dirty state and update VS Code's
+        // internal mtime tracker. Since WE just wrote the file, its mtime is from
+        // our write (not the external change), avoiding the "content is newer" conflict.
+        const serializeTokenSource = new CancellationTokenSource();
         try {
-            await workspace.save(notebook.uri);
-        } catch (error) {
-            this.consumeSelfWrite(notebook.uri);
-            throw error;
+            const serializedBytes = await this.serializer.serializeNotebook(newData, serializeTokenSource.token);
+
+            // Write to disk first — this updates the file mtime to "now"
+            this.markSelfWrite(fileUri);
+            try {
+                await workspace.fs.writeFile(fileUri, serializedBytes);
+            } catch (writeError) {
+                this.consumeSelfWrite(fileUri);
+                logger.warn(`[FileChangeWatcher] Failed to write synced file: ${fileUri.path}`, writeError);
+
+                // Bail out — without a successful write, workspace.save() would hit
+                // the stale mtime and show a "content is newer" conflict dialog.
+                // The notebook stays dirty but cells are already up-to-date from applyEdit.
+                return;
+            }
+
+            // Save to clear dirty state. VS Code serializes (same bytes) and sees the
+            // mtime from our recent write, so no "content is newer" conflict.
+            // NOTE: onDidSaveNotebookDocument handles the self-write mark for this save.
+            try {
+                const saved = await workspace.save(notebook.uri);
+                if (!saved) {
+                    logger.warn(`[FileChangeWatcher] Save after sync write returned undefined: ${notebook.uri.path}`);
+                    return;
+                }
+            } catch (saveError) {
+                logger.warn(`[FileChangeWatcher] Save after sync write failed: ${notebook.uri.path}`, saveError);
+            }
+        } catch (serializeError) {
+            logger.warn(`[FileChangeWatcher] Failed to serialize for sync write: ${fileUri.path}`, serializeError);
+        } finally {
+            serializeTokenSource.dispose();
         }
 
         logger.info(`[FileChangeWatcher] Reloaded notebook from external change: ${notebook.uri.path}`);
@@ -452,9 +505,13 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
                 }
             }
             if (metadataEdits.length > 0) {
-                const wsEdit = new WorkspaceEdit();
-                wsEdit.set(notebook.uri, metadataEdits);
-                await workspace.applyEdit(wsEdit);
+                const metadataApplied = await this.applyNotebookEdits(notebook.uri, metadataEdits);
+                if (!metadataApplied) {
+                    logger.warn(
+                        `[FileChangeWatcher] Failed to restore block IDs via execution path: ${notebook.uri.path}`
+                    );
+                    return;
+                }
             }
 
             logger.info(`[FileChangeWatcher] Updated notebook outputs via execution API: ${notebook.uri.path}`);
@@ -482,9 +539,7 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
             );
         }
 
-        const wsEdit = new WorkspaceEdit();
-        wsEdit.set(notebook.uri, replaceEdits);
-        const applied = await workspace.applyEdit(wsEdit);
+        const applied = await this.applyNotebookEdits(notebook.uri, replaceEdits);
 
         if (!applied) {
             logger.warn(`[FileChangeWatcher] Failed to apply snapshot outputs: ${notebook.uri.path}`);
@@ -503,26 +558,32 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
                 })
             );
         }
-        const metaEdit = new WorkspaceEdit();
-        metaEdit.set(notebook.uri, metadataEdits);
-        await workspace.applyEdit(metaEdit);
-
-        // Save to sync mtime — mark as self-write first
-        this.markSelfWrite(notebook.uri);
-        try {
-            await workspace.save(notebook.uri);
-        } catch (error) {
-            this.consumeSelfWrite(notebook.uri);
-            throw error;
+        const metadataApplied = await this.applyNotebookEdits(notebook.uri, metadataEdits);
+        if (!metadataApplied) {
+            logger.warn(`[FileChangeWatcher] Failed to restore block IDs after replaceCells: ${notebook.uri.path}`);
+            return;
         }
 
+        // Save to sync mtime.
+        // NOTE: onDidSaveNotebookDocument handles the self-write mark for this save.
+        await workspace.save(notebook.uri);
+
         logger.info(`[FileChangeWatcher] Updated notebook outputs from external snapshot: ${notebook.uri.path}`);
     }
 
     private getBlockIdFromMetadata(metadata: Record<string, unknown> | undefined): string | undefined {
         return (metadata?.__deepnoteBlockId ?? metadata?.id) as string | undefined;
     }
 
+    /**
+     * Normalizes a URI to the underlying file path by stripping query and fragment.
+     * Notebook URIs include query params (e.g., ?notebook=id) but the filesystem
+     * watcher fires with the raw file URI — keys must match for self-write detection.
+     */
+    private normalizeFileUri(uri: Uri): string {
+        return uri.with({ query: '', fragment: '' }).toString();
+    }
+
     private handleFileChange(uri: Uri): void {
         // Deterministic self-write check — no timers involved
         if (this.consumeSelfWrite(uri)) {
@@ -577,11 +638,12 @@ export class DeepnoteFileChangeWatcher implements IExtensionSyncActivationServic
     }
 
     /**
-     * Marks a URI as about to be written by us (workspace.save).
-     * Call before workspace.save() to prevent the resulting fs event from triggering a reload.
+     * Marks a URI as about to be written by us.
+     * For workspace.fs.writeFile(): call this before the write.
+     * For workspace.save(): do NOT call this — onDidSaveNotebookDocument handles it.
      */
     private markSelfWrite(uri: Uri): void {
-        const key = uri.toString();
+        const key = this.normalizeFileUri(uri);
         const count = this.selfWriteCounts.get(key) ?? 0;
         this.selfWriteCounts.set(key, count + 1);