@push.rocks/smartrust 1.4.1 → 1.6.0

package/ts/classes.sockettransport.ts

@@ -1,7 +1,10 @@
 import * as plugins from './plugins.js';
 import { LineScanner } from './classes.linescanner.js';
 import type { IRustBridgeLogger } from './interfaces/index.js';
-import type { IRustTransport } from './interfaces/transport.js';
+import type {
+  IRustTransport,
+  IRustTransportDisconnectOptions,
+} from './interfaces/transport.js';
 
 export interface ISocketTransportOptions {
   /** Path to Unix socket (Linux/macOS) or named pipe path (Windows) */
@@ -30,6 +33,18 @@ interface IResolvedSocketTransportOptions {
   maxReconnectAttempts: number;
 }
 
+interface ISocketTransportGeneration {
+  socket: plugins.net.Socket;
+  lifecycleToken: number;
+  reconnectAttempt: boolean;
+  everConnected: boolean;
+  connectSettled: boolean;
+  closed: boolean;
+  closePromise: Promise<void>;
+  resolveClose: () => void;
+  disconnectPromise: Promise<void> | null;
+}
+
 /**
  * Transport that connects to an already-running process via Unix socket or Windows named pipe.
  * The JSON-over-newline protocol is identical to stdio; only the transport changes.
@@ -37,11 +52,15 @@ interface IResolvedSocketTransportOptions {
 export class SocketTransport extends plugins.events.EventEmitter implements IRustTransport {
   private options: IResolvedSocketTransportOptions;
   private socket: plugins.net.Socket | null = null;
+  private generation: ISocketTransportGeneration | null = null;
   private lineScanner: LineScanner;
   private _connected: boolean = false;
   private intentionalDisconnect: boolean = false;
   private reconnectAttempts: number = 0;
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private lifecycleToken: number = 0;
+  private _reconnecting: boolean = false;
+  private reconnectFailed: boolean = false;
 
   constructor(options: ISocketTransportOptions) {
     super();
@@ -59,105 +78,274 @@ export class SocketTransport extends plugins.events.EventEmitter implements IRus
     return this._connected;
   }
 
+  public get reconnecting(): boolean {
+    return !this.intentionalDisconnect && this._reconnecting;
+  }
+
   /**
    * Connect to the socket. Resolves when the TCP/Unix connection is established.
    */
-  public async connect(): Promise<void> {
+  public connect(): Promise<void> {
+    if (this.generation && !this.generation.closed) {
+      return Promise.reject(
+        new Error('Socket transport already has an active connection attempt or connection'),
+      );
+    }
+
+    this.cancelReconnectTimer();
+    const lifecycleToken = ++this.lifecycleToken;
     this.intentionalDisconnect = false;
+    this._reconnecting = false;
+    this.reconnectFailed = false;
     this.reconnectAttempts = 0;
-    return this.doConnect();
+    return this.doConnect(lifecycleToken, false);
   }
 
-  private doConnect(): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      let settled = false;
+  private doConnect(
+    lifecycleToken: number,
+    reconnectAttempt: boolean,
+  ): Promise<void> {
+    if (
+      lifecycleToken !== this.lifecycleToken
+      || this.intentionalDisconnect
+    ) {
+      return Promise.reject(new Error('Socket connection attempt was cancelled'));
+    }
+    if (this.generation && !this.generation.closed) {
+      return Promise.reject(
+        new Error('Socket transport already has an active connection attempt or connection'),
+      );
+    }
 
-      this.socket = plugins.net.connect({ path: this.options.socketPath });
+    const socket = new plugins.net.Socket();
+    let resolveConnect!: () => void;
+    let rejectConnect!: (error: Error) => void;
+    const connectPromise = new Promise<void>((resolve, reject) => {
+      resolveConnect = resolve;
+      rejectConnect = reject;
+    });
+    let resolveClose!: () => void;
+    const closePromise = new Promise<void>((resolve) => {
+      resolveClose = resolve;
+    });
+    const generation: ISocketTransportGeneration = {
+      socket,
+      lifecycleToken,
+      reconnectAttempt,
+      everConnected: false,
+      connectSettled: false,
+      closed: false,
+      closePromise,
+      resolveClose,
+      disconnectPromise: null,
+    };
 
-      this.socket.on('connect', () => {
-        if (!settled) {
-          settled = true;
-          this._connected = true;
-          this.reconnectAttempts = 0;
-          resolve();
-        }
-      });
+    this.generation = generation;
+    this.socket = socket;
 
-      this.socket.on('data', (chunk: Buffer) => {
-        this.lineScanner.push(chunk, (line) => {
-          this.emit('line', line);
-        });
-      });
+    socket.on('connect', () => {
+      if (this.generation !== generation || generation.closed) {
+        return;
+      }
 
-      this.socket.on('close', () => {
-        const wasConnected = this._connected;
-        this._connected = false;
-        this.lineScanner.clear();
+      generation.everConnected = true;
+      this._connected = true;
+      if (generation.reconnectAttempt) {
+        this._reconnecting = false;
+      }
+      this.reconnectAttempts = 0;
+      if (!generation.connectSettled) {
+        generation.connectSettled = true;
+        resolveConnect();
+      }
+    });
 
-        if (!this.intentionalDisconnect && wasConnected && this.options.autoReconnect) {
-          this.attemptReconnect();
-        }
-        this.emit('close');
-      });
+    socket.on('data', (chunk: Buffer) => {
+      if (this.generation !== generation || generation.closed) {
+        return;
+      }
 
-      this.socket.on('error', (err: Error) => {
-        this._connected = false;
-        if (!settled) {
-          settled = true;
-          reject(err);
-        } else if (!this.intentionalDisconnect) {
-          this.emit('error', err);
+      this.lineScanner.push(chunk, (line) => {
+        if (this.generation === generation && !generation.closed) {
+          this.emit('line', line);
         }
       });
     });
+
+    socket.on('close', () => {
+      if (generation.closed) {
+        return;
+      }
+
+      generation.closed = true;
+      if (!generation.connectSettled) {
+        generation.connectSettled = true;
+        rejectConnect(new Error('Socket closed before connection was established'));
+      }
+      generation.resolveClose();
+
+      if (this.generation !== generation) {
+        return;
+      }
+
+      this._connected = false;
+      this.socket = null;
+      this.lineScanner.clear();
+
+      const shouldReconnect = (
+        !this.intentionalDisconnect
+        && generation.lifecycleToken === this.lifecycleToken
+        && this.options.autoReconnect
+        && (generation.everConnected || generation.reconnectAttempt)
+      );
+      if (shouldReconnect) {
+        this._reconnecting = true;
+      }
+      this.emit('close');
+
+      // A close listener may intentionally disconnect or start a new generation.
+      // Only the still-current closed generation may schedule the retry.
+      if (
+        shouldReconnect
+        && this.generation === generation
+        && !this.intentionalDisconnect
+        && generation.lifecycleToken === this.lifecycleToken
+      ) {
+        this.attemptReconnect(generation.lifecycleToken);
+      }
+    });
+
+    socket.on('error', (error: Error) => {
+      if (this.generation !== generation || generation.closed) {
+        return;
+      }
+
+      this._connected = false;
+      if (!generation.connectSettled) {
+        generation.connectSettled = true;
+        rejectConnect(error);
+      } else if (!this.intentionalDisconnect) {
+        this.emit('error', error);
+      }
+    });
+
+    try {
+      socket.connect({ path: this.options.socketPath });
+    } catch (error: unknown) {
+      const connectError = this.toError(error, 'Failed to initiate socket connection');
+      generation.closed = true;
+      if (!generation.connectSettled) {
+        generation.connectSettled = true;
+        rejectConnect(connectError);
+      }
+      generation.resolveClose();
+      if (this.generation === generation) {
+        this._connected = false;
+        this.socket = null;
+        this.lineScanner.clear();
+      }
+      if (
+        reconnectAttempt
+        && !this.intentionalDisconnect
+        && lifecycleToken === this.lifecycleToken
+      ) {
+        this.attemptReconnect(lifecycleToken);
+      }
+    }
+
+    return connectPromise;
   }
 
-  private attemptReconnect(): void {
+  private attemptReconnect(lifecycleToken: number): void {
+    if (
+      lifecycleToken !== this.lifecycleToken
+      || this.intentionalDisconnect
+      || this.reconnectFailed
+      || this.reconnectTimer
+      || (this.generation && !this.generation.closed)
+    ) {
+      return;
+    }
+
     if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
-      this.options.logger.log('error', `Max reconnect attempts (${this.options.maxReconnectAttempts}) reached`);
+      this._reconnecting = false;
+      this.reconnectFailed = true;
+      ++this.lifecycleToken;
+      this.options.logger.log(
+        'error',
+        'Max reconnect attempts (' + this.options.maxReconnectAttempts + ') reached',
+      );
       this.emit('reconnect_failed');
       return;
     }
 
+    this._reconnecting = true;
+
     const delay = Math.min(
       this.options.reconnectBaseDelayMs * Math.pow(2, this.reconnectAttempts),
       this.options.reconnectMaxDelayMs,
     );
     this.reconnectAttempts++;
 
-    this.options.logger.log('info', `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.options.maxReconnectAttempts})`);
+    this.options.logger.log(
+      'info',
+      'Reconnecting in '
+        + delay
+        + 'ms (attempt '
+        + this.reconnectAttempts
+        + '/'
+        + this.options.maxReconnectAttempts
+        + ')',
+    );
 
-    this.reconnectTimer = setTimeout(async () => {
+    this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
-      try {
-        await this.doConnect();
-        this.emit('reconnected');
-      } catch {
-        // doConnect rejected — the 'close' handler on the new socket will trigger another attempt
+      if (
+        lifecycleToken !== this.lifecycleToken
+        || this.intentionalDisconnect
+      ) {
+        return;
       }
+
+      void this.doConnect(lifecycleToken, true).then(() => {
+        if (
+          lifecycleToken === this.lifecycleToken
+          && !this.intentionalDisconnect
+        ) {
+          this.emit('reconnected');
+        }
+      }).catch(() => {
+        // The generation's close handler schedules the next reconnect attempt.
+      });
     }, delay);
   }
 
   /**
    * Write data to the socket with backpressure support.
    */
-  public async write(data: string): Promise<void> {
+  public write(data: string): Promise<void> {
     return new Promise<void>((resolve, reject) => {
-      if (!this.socket || !this._connected) {
+      const generation = this.generation;
+      if (
+        !generation
+        || generation.closed
+        || generation.socket !== this.socket
+        || !this._connected
+      ) {
         reject(new Error('Socket not connected'));
         return;
       }
 
-      const canContinue = this.socket.write(data, 'utf8', (err) => {
-        if (err) {
-          reject(err);
+      const canContinue = generation.socket.write(data, 'utf8', (error) => {
+        if (error) {
+          reject(error);
         }
       });
 
       if (canContinue) {
         resolve();
       } else {
-        this.socket.once('drain', () => {
+        generation.socket.once('drain', () => {
           resolve();
         });
       }
@@ -165,23 +353,79 @@ export class SocketTransport extends plugins.events.EventEmitter implements IRus
   }
 
   /**
-   * Close the socket connection. Does NOT kill the remote daemon.
+   * Close the local socket without waiting for confirmation.
+   * This does not kill the remote daemon.
    */
   public disconnect(): void {
+    try {
+      void this.disconnectAndWait().catch((error: unknown) => {
+        this.options.logger.log(
+          'error',
+          'Failed to disconnect socket transport: ' + this.getErrorMessage(error),
+        );
+      });
+    } catch (error: unknown) {
+      this.options.logger.log(
+        'error',
+        'Failed to disconnect socket transport: ' + this.getErrorMessage(error),
+      );
+    }
+  }
+
+  /**
+   * Destroy the local socket and wait until its 'close' event confirms closure.
+   * This does not signal or otherwise terminate the remote daemon.
+   */
+  public disconnectAndWait(
+    _options: IRustTransportDisconnectOptions = {},
+  ): Promise<void> {
     this.intentionalDisconnect = true;
+    this._reconnecting = false;
+    ++this.lifecycleToken;
+    this.cancelReconnectTimer();
+
+    const generation = this.generation;
+    if (!generation) {
+      return Promise.resolve();
+    }
+    if (generation.disconnectPromise) {
+      return generation.disconnectPromise;
+    }
+    if (generation.closed) {
+      generation.disconnectPromise = generation.closePromise;
+      return generation.disconnectPromise;
+    }
+
+    this._connected = false;
+    let rejectDisconnect!: (error: Error) => void;
+    const disconnectPromise = new Promise<void>((resolve, reject) => {
+      rejectDisconnect = reject;
+      void generation.closePromise.then(resolve);
+    });
+    generation.disconnectPromise = disconnectPromise;
 
+    // The close waiter above must exist before destroy() can cause 'close'.
+    try {
+      generation.socket.destroy();
+    } catch (error: unknown) {
+      rejectDisconnect(this.toError(error, 'Failed to destroy local socket'));
+    }
+
+    return disconnectPromise;
+  }
+
+  private cancelReconnectTimer(): void {
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
+  }
 
-    if (this.socket) {
-      const sock = this.socket;
-      this.socket = null;
-      this._connected = false;
-      this.lineScanner.clear();
-      sock.removeAllListeners();
-      sock.destroy();
-    }
+  private toError(error: unknown, prefix: string): Error {
+    return new Error(prefix + ': ' + this.getErrorMessage(error));
+  }
+
+  private getErrorMessage(error: unknown): string {
+    return error instanceof Error ? error.message : String(error);
   }
 }