Preserve renamed session names through reconnect

PEZ · PEZ · commit a453645d3ebc · 2026-05-07T16:07:36.000+02:00
* Fixes #3207
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -3,7 +3,9 @@
 Changes to Calva.
 
 ## [Unreleased]
-- enable new clojure-lsp code actions: inline function, if<->cond, extract selection to function, move to :let
+
+- [enable new clojure-lsp code actions: inline function, if<->cond, extract selection to function, move to :let](https://github.com/BetterThanTomorrow/calva/issues/3204)
+- Fix: [Calva forgets the renamed session name on disconnect->reconnect](https://github.com/BetterThanTomorrow/calva/issues/3207)
 
 ## [2.0.583] - 2026-05-04
 
diff --git a/src/connector.ts b/src/connector.ts
@@ -98,6 +98,7 @@ async function connectViaWebSocket(
   isJackIn = false
 ): Promise<ConnectResult> {
   let activeClient: nrepl.NReplClient | undefined;
+  let preservedRenames: Partial<sessionRoleUtils.SessionRoleKeys> | undefined;
   const baseSessionNames = sessionRoleUtils.deriveSessionRoleKeys(connectSequence);
   const projectRootPath = state.getProjectRootUri().fsPath;
   const projectRoot = state.getProjectRootUri().toString();
@@ -193,6 +194,7 @@ async function connectViaWebSocket(
           connectSequence,
           baseSessionNames,
           suffix: resolution.suffix,
+          renamedSessionNames: preservedRenames,
         },
       });
 
@@ -211,19 +213,29 @@ async function connectViaWebSocket(
       });
       clientRegistry.setCljcTargetForConnection(client.clientKey, 'primary');
 
+      // Apply preserved rename from previous browser connection
+      const renamedPrimary = preservedRenames?.primary;
+      if (renamedPrimary && renamedPrimary !== mainKey) {
+        sessionRegistry.renameSession(mainKey, renamedPrimary);
+      }
+      const effectiveMainKey = renamedPrimary ?? mainKey;
+      preservedRenames = undefined;
+
       status.update();
-      output.appendLineOtherOut(`Connected session: ${mainKey}, ws://${wsHost}:${currentPort}`);
+      output.appendLineOtherOut(
+        `Connected session: ${effectiveMainKey}, ws://${wsHost}:${currentPort}`
+      );
       replSession.updateReplSessionType();
 
-      outputWindow.setSession(mainSession, client.ns, mainKey);
+      outputWindow.setSession(mainSession, client.ns, effectiveMainKey);
 
       if (config.getConfig().autoEvaluateCode.onConnect.clj) {
         output.appendLineOtherOut(
           `Evaluating code from settings: 'calva.autoEvaluateCode.onConnect.clj'`
         );
         await evaluate.evaluateInOutputWindow(
           config.getConfig().autoEvaluateCode.onConnect.clj,
-          mainKey,
+          effectiveMainKey,
           outputWindow.getNs(),
           {}
         );
@@ -234,7 +246,12 @@ async function connectViaWebSocket(
         connectSequence.afterPrimaryReplConnectedCode ?? connectSequence.afterCLJReplJackInCode;
       if (afterMainReplCode) {
         output.appendLineOtherOut(`Evaluating 'afterPrimaryReplConnectedCode'`);
-        await evaluate.evaluateInOutputWindow(afterMainReplCode, mainKey, outputWindow.getNs(), {});
+        await evaluate.evaluateInOutputWindow(
+          afterMainReplCode,
+          effectiveMainKey,
+          outputWindow.getNs(),
+          {}
+        );
       }
       if (!connectSequence.cljsType || connectSequence.cljsType === 'none') {
         output.maybePrintLegacyREPLWindowOutputMessage();
@@ -305,6 +322,9 @@ async function connectViaWebSocket(
         output.appendLineOtherOut('Browser REPL disconnected, waiting for reconnection...');
         state.connectionLogChannel().appendLine('Browser REPL disconnected');
 
+        // Preserve renames across browser reconnections
+        preservedRenames = clientRegistry.getConnectionState(clientKey)?.renamedSessionNames;
+
         // Clean up client and sessions but keep server alive
         clientTeardown.releaseClientSuffix(clientKey);
         const wasRegistered = clientRegistry.unregisterClient(clientKey);
@@ -466,6 +486,7 @@ async function connectToHost(
         connectSequence,
         baseSessionNames,
         suffix: resolution.suffix,
+        renamedSessionNames: resolution.renamedSessionNames,
       },
     });
     localClient.addOnCloseHandler((c) => {
@@ -504,19 +525,26 @@ async function connectToHost(
     });
     clientRegistry.setCljcTargetForConnection(localClient.clientKey, 'primary');
 
+    // Apply preserved rename from previous connection
+    const renamedPrimary = resolution.renamedSessionNames?.primary;
+    if (renamedPrimary && renamedPrimary !== mainKey) {
+      sessionRegistry.renameSession(mainKey, renamedPrimary);
+    }
+    const effectivePrimaryKey = renamedPrimary ?? mainKey;
+
     status.update();
-    output.appendLineOtherOut(`Connected session: ${mainKey}, port: ${port}`);
+    output.appendLineOtherOut(`Connected session: ${effectivePrimaryKey}, port: ${port}`);
     replSession.updateReplSessionType();
 
-    outputWindow.setSession(mainSession, localClient.ns, mainKey);
+    outputWindow.setSession(mainSession, localClient.ns, effectivePrimaryKey);
 
     if (config.getConfig().autoEvaluateCode.onConnect.clj) {
       output.appendLineOtherOut(
         `Evaluating code from settings: 'calva.autoEvaluateCode.onConnect.clj'`
       );
       await evaluate.evaluateInOutputWindow(
         config.getConfig().autoEvaluateCode.onConnect.clj,
-        mainKey,
+        effectivePrimaryKey,
         outputWindow.getNs(),
         {}
       );
@@ -527,14 +555,19 @@ async function connectToHost(
       connectSequence.afterPrimaryReplConnectedCode ?? connectSequence.afterCLJReplJackInCode;
     if (afterMainReplCode) {
       output.appendLineOtherOut(`Evaluating 'afterPrimaryReplConnectedCode'`);
-      await evaluate.evaluateInOutputWindow(afterMainReplCode, mainKey, outputWindow.getNs(), {});
+      await evaluate.evaluateInOutputWindow(
+        afterMainReplCode,
+        effectivePrimaryKey,
+        outputWindow.getNs(),
+        {}
+      );
     }
     if (!connectSequence.cljsType || connectSequence.cljsType === 'none') {
       output.maybePrintLegacyREPLWindowOutputMessage();
     }
     void output.replWindowAppendPrompt();
 
-    clojureDocs.probeAndSetSession(mainSession, mainKey);
+    clojureDocs.probeAndSetSession(mainSession, effectivePrimaryKey);
 
     let cljsSession = null,
       cljsBuild = null;
@@ -700,24 +733,34 @@ async function setUpCljsRepl(
   });
   clientRegistry.setCljcTargetForConnection(clientKey, 'secondary');
 
-  clojureDocs.probeAndSetSession(session, cljsKey);
+  // Apply preserved rename from previous connection
+  const renamedSecondary =
+    clientRegistry.getConnectionState(clientKey)?.renamedSessionNames?.secondary;
+  const effectiveCljsKey =
+    renamedSecondary && renamedSecondary !== cljsKey
+      ? (sessionRegistry.renameSession(cljsKey, renamedSecondary), renamedSecondary)
+      : cljsKey;
+
+  clojureDocs.probeAndSetSession(session, effectiveCljsKey);
 
   status.update();
-  output.appendLineOtherOut(`Connected session: ${cljsKey}${build ? ', repl: ' + build : ''}`);
+  output.appendLineOtherOut(
+    `Connected session: ${effectiveCljsKey}${build ? ', repl: ' + build : ''}`
+  );
   outputWindow.appendLine(
     resultsOutputUtil.formatAsLineComments(outputWindow.CLJS_CONNECT_GREETINGS)
   );
   const description = await session.describe(true);
   const ns = description.aux?.['current-ns'] || 'user';
   await session.eval(`(in-ns '${ns})`, 'user').value;
-  outputWindow.setSession(session, ns, cljsKey);
+  outputWindow.setSession(session, ns, effectiveCljsKey);
   if (config.getConfig().autoEvaluateCode.onConnect.cljs) {
     output.appendLineOtherOut(
       `Evaluating code from settings: 'calva.autoEvaluateCode.onConnect.cljs'`
     );
     await evaluate.evaluateInOutputWindow(
       config.getConfig().autoEvaluateCode.onConnect.cljs,
-      cljsKey,
+      effectiveCljsKey,
       ns,
       {}
     );
diff --git a/src/extension-test/integration/suite/websocket-connect-test.ts b/src/extension-test/integration/suite/websocket-connect-test.ts
@@ -12,6 +12,7 @@ import * as docMirror from '../../../doc-mirror';
 
 const WS_PORT_EVAL = 51340;
 const WS_PORT_LOAD = 51341;
+const WS_PORT_RENAME = 51342;
 
 /**
  * Create a scittle webview via Joyride flare.
@@ -262,4 +263,102 @@ suite('WebSocket nREPL Connect suite', function () {
     testUtil.log(suite, `[TIMING] Test 2 complete: ${elapsed()}`);
     await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
   });
+
+  test('Renamed session survives browser reconnection', async function () {
+    const t0 = Date.now();
+    const elapsed = () => `${Date.now() - t0}ms`;
+    testUtil.log(suite, 'Renamed session survives browser reconnection');
+
+    const projectDir = path.join(
+      testUtil.testDataDir,
+      '..',
+      'projects',
+      'scittle-replicant-tic-tac-toe'
+    );
+
+    const connectSequence: connectSequenceTypes.ReplConnectSequence = {
+      name: 'scittle-ws-test',
+      projectType: connectSequenceTypes.ProjectTypes['scittle'],
+      cljsType: connectSequenceTypes.CljsTypes.none,
+      webSocketPort: WS_PORT_RENAME,
+      projectRootPath: [projectDir],
+    };
+
+    // 1. Connect via WebSocket
+    const connectPromise = connector.connect(connectSequence, true);
+
+    await testUtil.waitForCondition(
+      () => testUtil.canConnectToPort(WS_PORT_RENAME),
+      5_000,
+      20,
+      `WS server not listening on port ${WS_PORT_RENAME}`
+    );
+
+    await vscode.commands.executeCommand('joyride.runCode', flareCode(WS_PORT_RENAME));
+    const result = await connectPromise;
+    assert.ok(result.connected, 'Initial WS connection should succeed');
+    testUtil.log(suite, `[TIMING] Initial connection: ${elapsed()}`);
+
+    // 2. Verify original session name and rename it
+    const originalSessions = sessionRegistry.listSessions();
+    const originalKey = originalSessions[0].key;
+    testUtil.log(suite, `Original session key: ${originalKey}`);
+
+    const renamedKey = 'my-scittle';
+    const renamed = sessionRegistry.renameSession(originalKey, renamedKey);
+    assert.ok(renamed, 'Rename should succeed');
+    assert.ok(sessionRegistry.getSession(renamedKey), 'Session should exist under renamed key');
+    testUtil.log(suite, `Renamed to: ${renamedKey}, ${elapsed()}`);
+
+    // 3. Close the webview (simulates browser tab close / reload)
+    await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
+    testUtil.log(suite, `[TIMING] Webview closed: ${elapsed()}`);
+
+    // Wait for disconnect to clean up sessions
+    await testUtil.waitForCondition(
+      () => sessionRegistry.listSessions().length === 0,
+      5_000,
+      20,
+      'Timed out waiting for session cleanup after webview close'
+    );
+    testUtil.log(suite, `[TIMING] Sessions cleaned up: ${elapsed()}`);
+
+    // 4. Re-open webview (browser reconnects to the still-listening WS server)
+    await vscode.commands.executeCommand('joyride.runCode', flareCode(WS_PORT_RENAME));
+    testUtil.log(suite, `[TIMING] Webview re-opened: ${elapsed()}`);
+
+    // 5. Wait for session to be re-registered
+    await testUtil.waitForCondition(
+      () => sessionRegistry.listSessions().length > 0,
+      10_000,
+      50,
+      'Timed out waiting for session after browser reconnection'
+    );
+
+    // 6. Verify the renamed key survived the reconnection
+    const reconnectedSessions = sessionRegistry.listSessions();
+    const reconnectedKeys = reconnectedSessions.map((s) => s.key);
+    testUtil.log(suite, `Reconnected session keys: ${reconnectedKeys.join(', ')}`);
+
+    assert.ok(
+      reconnectedKeys.includes(renamedKey),
+      `Renamed key '${renamedKey}' should survive browser reconnection, got: ${reconnectedKeys.join(
+        ', '
+      )}`
+    );
+    assert.ok(
+      !reconnectedKeys.includes(originalKey),
+      `Original key '${originalKey}' should not reappear after reconnection`
+    );
+
+    // 7. Verify the session is functional
+    const session = sessionRegistry.getSession(renamedKey);
+    assert.ok(session, 'Should get session by renamed key');
+    const evalResult = await session.eval('(+ 10 20)', 'user').value;
+    assert.strictEqual(evalResult, '30', 'Eval through renamed session should work');
+    testUtil.log(suite, `Eval via renamed session: (+ 10 20) => ${evalResult}`);
+
+    await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
+    testUtil.log(suite, `[TIMING] Test 3 complete: ${elapsed()}`);
+  });
 });
diff --git a/src/extension-test/unit/nrepl/session-registry-test.ts b/src/extension-test/unit/nrepl/session-registry-test.ts
@@ -233,5 +233,35 @@ describe('session registry', () => {
       const nextSuffix = sessionNameSuffix.acquireNextAvailableSuffix();
       expectLib.expect(nextSuffix).toBe('2');
     });
+
+    it('stores renamedSessionNames in ConnectionState for primary', () => {
+      clientRegistry.registerClient(createMockClient('client-a'), {
+        connectionState: {
+          sessionRoleKeys: { primary: 'clj', secondary: 'cljs' },
+        },
+      });
+      sessionRegistry.registerSession('clj', createSession('client-a'), {});
+
+      sessionRegistry.renameSession('clj', 'my-clj');
+
+      const state = clientRegistry.getConnectionState('client-a');
+      expectLib.expect(state?.renamedSessionNames).toEqual({ primary: 'my-clj' });
+    });
+
+    it('stores renamedSessionNames in ConnectionState for secondary', () => {
+      clientRegistry.registerClient(createMockClient('client-a'), {
+        connectionState: {
+          sessionRoleKeys: { primary: 'clj', secondary: 'cljs' },
+        },
+      });
+      sessionRegistry.registerSession('cljs', createSession('client-a'), {
+        isSecondary: true,
+      });
+
+      sessionRegistry.renameSession('cljs', 'my-cljs');
+
+      const state = clientRegistry.getConnectionState('client-a');
+      expectLib.expect(state?.renamedSessionNames).toEqual({ secondary: 'my-cljs' });
+    });
   });
 });
diff --git a/src/extension-test/unit/session-name-resolver-test.ts b/src/extension-test/unit/session-name-resolver-test.ts
@@ -195,6 +195,31 @@ describe('session-name-resolver', () => {
         expectLib.expect(resolution.suffix).toBe('2');
       });
 
+      it('passes through renamedSessionNames from previous connection', () => {
+        const baseNames = { primary: 'clj', secondary: 'cljs' };
+        const projectRoot = '/test-project';
+
+        clientRegistry.registerClient(createMockClient('client-a'), {
+          projectRoot,
+          host: 'localhost',
+          port: 1234,
+          connectionState: {
+            baseSessionNames: baseNames,
+            renamedSessionNames: { primary: 'my-clj' },
+          },
+        });
+
+        const resolution = sessionNameResolver.resolveSessionNames(
+          baseNames,
+          projectRoot,
+          'localhost',
+          1234
+        );
+
+        expectLib.expect(resolution.reconnectClientKey).toBe('client-a');
+        expectLib.expect(resolution.renamedSessionNames).toEqual({ primary: 'my-clj' });
+      });
+
       it('detects reconnection even when projectRoot differs (matches on host:port)', () => {
         const baseNames = { primary: 'clj', secondary: 'cljs' };
 
diff --git a/src/nrepl/client-registry.ts b/src/nrepl/client-registry.ts
@@ -23,6 +23,8 @@ export interface ConnectionState {
   suffix?: string;
   /** Which session role should handle .cljc files for this connection */
   cljcTarget?: CljcTargetRole;
+  /** User-assigned custom names per role, preserved across reconnection */
+  renamedSessionNames?: Partial<sessionRoleUtils.SessionRoleKeys>;
 }
 
 export interface RegisteredClient {
diff --git a/src/nrepl/session-name-resolver.ts b/src/nrepl/session-name-resolver.ts
@@ -19,6 +19,9 @@ export interface SessionNameResolution {
 
   /** Client to disconnect for reconnection, if any */
   reconnectClientKey?: string;
+
+  /** User-assigned custom names from the previous connection, if any */
+  renamedSessionNames?: Partial<sessionRoleUtils.SessionRoleKeys>;
 }
 
 /**
@@ -157,6 +160,7 @@ export function resolveSessionNames(
       finalNames,
       suffix: existingSuffix,
       reconnectClientKey,
+      renamedSessionNames: existingState?.renamedSessionNames,
     };
   }
 
diff --git a/src/nrepl/session-registry.ts b/src/nrepl/session-registry.ts

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,8 @@ export interface ConnectionState {`
`23`	`23`	`suffix?: string;`
`24`	`24`	`/** Which session role should handle .cljc files for this connection */`
`25`	`25`	`cljcTarget?: CljcTargetRole;`
	`26`	`+ /** User-assigned custom names per role, preserved across reconnection */`
	`27`	`+ renamedSessionNames?: Partial<sessionRoleUtils.SessionRoleKeys>;`
`26`	`28`	`}`
`27`	`29`
`28`	`30`	`export interface RegisteredClient {`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,9 @@ export interface SessionNameResolution {`
`19`	`19`
`20`	`20`	`/** Client to disconnect for reconnection, if any */`
`21`	`21`	`reconnectClientKey?: string;`
	`22`	`+`
	`23`	`+ /** User-assigned custom names from the previous connection, if any */`
	`24`	`+ renamedSessionNames?: Partial<sessionRoleUtils.SessionRoleKeys>;`
`22`	`25`	`}`
`23`	`26`
`24`	`27`	`/**`
`@@ -157,6 +160,7 @@ export function resolveSessionNames(`
`157`	`160`	`finalNames,`
`158`	`161`	`suffix: existingSuffix,`
`159`	`162`	`reconnectClientKey,`
	`163`	`+ renamedSessionNames: existingState?.renamedSessionNames,`
`160`	`164`	`};`
`161`	`165`	`}`
`162`	`166`