feat(SocketModeReceiver): expose Socket Mode timeout and reconnect options

src/receivers/SocketModeReceiver.ts

@@ -39,6 +39,10 @@ export interface SocketModeReceiverOptions {
   installerOptions?: InstallerOptions;
   appToken: string; // App Level Token
   customRoutes?: CustomRoute[];
+  clientPingTimeout?: number;
+  serverPingTimeout?: number;
+  pingPongLoggingEnabled?: boolean;
+  autoReconnectEnabled?: boolean;
   // biome-ignore lint/suspicious/noExplicitAny: user-provided custom properties can be anything
   customPropertiesExtractor?: (args: any) => StringIndexed;
   processEventErrorHandler?: (args: SocketModeReceiverProcessEventErrorHandlerArgs) => Promise<boolean>;
@@ -96,6 +100,10 @@ export default class SocketModeReceiver implements Receiver {
     appToken,
     logger = undefined,
     logLevel = LogLevel.INFO,
+    clientPingTimeout = undefined,
+    serverPingTimeout = undefined,
+    pingPongLoggingEnabled = undefined,
+    autoReconnectEnabled = undefined,
     clientId = undefined,
     clientSecret = undefined,
     stateSecret = undefined,
@@ -111,6 +119,10 @@ export default class SocketModeReceiver implements Receiver {
       appToken,
       logLevel,
       logger,
+      clientPingTimeout,
+      serverPingTimeout,
+      pingPongLoggingEnabled,
+      autoReconnectEnabled,
       clientOptions: installerOptions.clientOptions,
     });
 

test/unit/receivers/SocketModeReceiver.spec.ts

@@ -1,3 +1,4 @@
+import { EventEmitter } from 'node:events';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import path from 'node:path';
 import { InstallProvider } from '@slack/oauth';
@@ -96,6 +97,115 @@ describe('SocketModeReceiver', () => {
       });
       assert.isNotNull(receiver);
     });
+    it('should pass clientPingTimeout to SocketModeClient', async () => {
+      const constructorSpy = sinon.spy();
+      class FakeSocketModeClient extends EventEmitter {
+        // biome-ignore lint/suspicious/noExplicitAny: test mock
+        constructor(opts: any) {
+          super();
+          constructorSpy(opts);
+        }
+      }
+      const smOverrides = mergeOverrides(overrides, {
+        '@slack/socket-mode': {
+          SocketModeClient: FakeSocketModeClient,
+        },
+      });
+      const SocketModeReceiver = importSocketModeReceiver(smOverrides);
+      const receiver = new SocketModeReceiver({
+        appToken: 'my-secret',
+        logger: noopLogger,
+        clientPingTimeout: 15000,
+      });
+      assert.isNotNull(receiver);
+      sinon.assert.calledOnce(constructorSpy);
+      const constructorArgs = constructorSpy.firstCall.args[0];
+      assert.equal(constructorArgs.clientPingTimeout, 15000);
+    });
+    it('should pass serverPingTimeout to SocketModeClient', async () => {
+      const constructorSpy = sinon.spy();
+      class FakeSocketModeClient extends EventEmitter {
+        // biome-ignore lint/suspicious/noExplicitAny: test mock
+        constructor(opts: any) {
+          super();
+          constructorSpy(opts);
+        }
+      }
+      const smOverrides = mergeOverrides(overrides, {
+        '@slack/socket-mode': {
+          SocketModeClient: FakeSocketModeClient,
+        },
+      });
+      const SocketModeReceiver = importSocketModeReceiver(smOverrides);
+      const receiver = new SocketModeReceiver({
+        appToken: 'my-secret',
+        logger: noopLogger,
+        serverPingTimeout: 60000,
+      });
+      assert.isNotNull(receiver);
+      sinon.assert.calledOnce(constructorSpy);
+      const constructorArgs = constructorSpy.firstCall.args[0];
+      assert.equal(constructorArgs.serverPingTimeout, 60000);
+    });
+    it('should pass all socket mode timeout options to SocketModeClient', async () => {
+      const constructorSpy = sinon.spy();
+      class FakeSocketModeClient extends EventEmitter {
+        // biome-ignore lint/suspicious/noExplicitAny: test mock
+        constructor(opts: any) {
+          super();
+          constructorSpy(opts);
+        }
+      }
+      const smOverrides = mergeOverrides(overrides, {
+        '@slack/socket-mode': {
+          SocketModeClient: FakeSocketModeClient,
+        },
+      });
+      const SocketModeReceiver = importSocketModeReceiver(smOverrides);
+      const receiver = new SocketModeReceiver({
+        appToken: 'my-secret',
+        logger: noopLogger,
+        clientPingTimeout: 15000,
+        serverPingTimeout: 60000,
+        pingPongLoggingEnabled: true,
+        autoReconnectEnabled: false,
+      });
+      assert.isNotNull(receiver);
+      sinon.assert.calledOnce(constructorSpy);
+      const constructorArgs = constructorSpy.firstCall.args[0];
+      assert.equal(constructorArgs.clientPingTimeout, 15000);
+      assert.equal(constructorArgs.serverPingTimeout, 60000);
+      assert.equal(constructorArgs.pingPongLoggingEnabled, true);
+      assert.equal(constructorArgs.autoReconnectEnabled, false);
+    });
+    it('should use defaults when socket mode timeout options are not provided', async () => {
+      const constructorSpy = sinon.spy();
+      class FakeSocketModeClient extends EventEmitter {
+        // biome-ignore lint/suspicious/noExplicitAny: test mock
+        constructor(opts: any) {
+          super();
+          constructorSpy(opts);
+        }
+      }
+      const smOverrides = mergeOverrides(overrides, {
+        '@slack/socket-mode': {
+          SocketModeClient: FakeSocketModeClient,
+        },
+      });
+      const SocketModeReceiver = importSocketModeReceiver(smOverrides);
+      const receiver = new SocketModeReceiver({
+        appToken: 'my-secret',
+        logger: noopLogger,
+      });
+      assert.isNotNull(receiver);
+      sinon.assert.calledOnce(constructorSpy);
+      const constructorArgs = constructorSpy.firstCall.args[0];
+      assert.equal(constructorArgs.appToken, 'my-secret');
+      assert.isUndefined(constructorArgs.clientPingTimeout);
+      assert.isUndefined(constructorArgs.serverPingTimeout);
+      assert.isUndefined(constructorArgs.pingPongLoggingEnabled);
+      assert.isUndefined(constructorArgs.autoReconnectEnabled);
+    });
     it('should throw an error if redirect uri options supplied invalid or incomplete', async () => {
       const SocketModeReceiver = importSocketModeReceiver(overrides);
       const clientId = 'my-clientId';