@push.rocks/smartrust 1.5.0 → 1.6.1

package/dist_ts/classes.sockettransport.d.ts

@@ -1,6 +1,6 @@
 import * as plugins from './plugins.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) */
     socketPath: string;
@@ -24,13 +24,18 @@ export interface ISocketTransportOptions {
 export declare class SocketTransport extends plugins.events.EventEmitter implements IRustTransport {
     private options;
     private socket;
+    private generation;
     private lineScanner;
     private _connected;
     private intentionalDisconnect;
     private reconnectAttempts;
     private reconnectTimer;
+    private lifecycleToken;
+    private _reconnecting;
+    private reconnectFailed;
     constructor(options: ISocketTransportOptions);
     get connected(): boolean;
+    get reconnecting(): boolean;
     /**
      * Connect to the socket. Resolves when the TCP/Unix connection is established.
      */
@@ -42,7 +47,16 @@ export declare class SocketTransport extends plugins.events.EventEmitter impleme
      */
     write(data: string): Promise<void>;
     /**
-     * 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.
      */
     disconnect(): void;
+    /**
+     * Destroy the local socket and wait until its 'close' event confirms closure.
+     * This does not signal or otherwise terminate the remote daemon.
+     */
+    disconnectAndWait(_options?: IRustTransportDisconnectOptions): Promise<void>;
+    private cancelReconnectTimer;
+    private toError;
+    private getErrorMessage;
 }

package/dist_ts/classes.sockettransport.js

@@ -7,11 +7,15 @@ import { LineScanner } from './classes.linescanner.js';
 export class SocketTransport extends plugins.events.EventEmitter {
     options;
     socket = null;
+    generation = null;
     lineScanner;
     _connected = false;
     intentionalDisconnect = false;
     reconnectAttempts = 0;
     reconnectTimer = null;
+    lifecycleToken = 0;
+    _reconnecting = false;
+    reconnectFailed = false;
     constructor(options) {
         super();
         this.options = {
@@ -26,113 +30,287 @@ export class SocketTransport extends plugins.events.EventEmitter {
     get connected() {
         return this._connected;
     }
+    get reconnecting() {
+        return !this.intentionalDisconnect && this._reconnecting;
+    }
     /**
      * Connect to the socket. Resolves when the TCP/Unix connection is established.
      */
-    async connect() {
+    connect() {
+        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);
     }
-    doConnect() {
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            this.socket = plugins.net.connect({ path: this.options.socketPath });
-            this.socket.on('connect', () => {
-                if (!settled) {
-                    settled = true;
-                    this._connected = true;
-                    this.reconnectAttempts = 0;
-                    resolve();
-                }
-            });
-            this.socket.on('data', (chunk) => {
-                this.lineScanner.push(chunk, (line) => {
+    doConnect(lifecycleToken, reconnectAttempt) {
+        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'));
+        }
+        const socket = new plugins.net.Socket();
+        let resolveConnect;
+        let rejectConnect;
+        const connectPromise = new Promise((resolve, reject) => {
+            resolveConnect = resolve;
+            rejectConnect = reject;
+        });
+        let resolveClose;
+        const closePromise = new Promise((resolve) => {
+            resolveClose = resolve;
+        });
+        const generation = {
+            socket,
+            lifecycleToken,
+            reconnectAttempt,
+            everConnected: false,
+            connectSettled: false,
+            closed: false,
+            closePromise,
+            resolveClose,
+            disconnectPromise: null,
+        };
+        this.generation = generation;
+        this.socket = socket;
+        socket.on('connect', () => {
+            if (this.generation !== generation || generation.closed) {
+                return;
+            }
+            generation.everConnected = true;
+            this._connected = true;
+            if (generation.reconnectAttempt) {
+                this._reconnecting = false;
+            }
+            this.reconnectAttempts = 0;
+            if (!generation.connectSettled) {
+                generation.connectSettled = true;
+                resolveConnect();
+            }
+        });
+        socket.on('data', (chunk) => {
+            if (this.generation !== generation || generation.closed) {
+                return;
+            }
+            this.lineScanner.push(chunk, (line) => {
+                if (this.generation === generation && !generation.closed) {
                     this.emit('line', line);
-                });
-            });
-            this.socket.on('close', () => {
-                const wasConnected = this._connected;
-                this._connected = false;
-                this.lineScanner.clear();
-                if (!this.intentionalDisconnect && wasConnected && this.options.autoReconnect) {
-                    this.attemptReconnect();
-                }
-                this.emit('close');
-            });
-            this.socket.on('error', (err) => {
-                this._connected = false;
-                if (!settled) {
-                    settled = true;
-                    reject(err);
-                }
-                else if (!this.intentionalDisconnect) {
-                    this.emit('error', err);
                 }
             });
         });
+        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) => {
+            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) {
+            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;
     }
-    attemptReconnect() {
+    attemptReconnect(lifecycleToken) {
+        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.reconnectTimer = setTimeout(async () => {
+        this.options.logger.log('info', 'Reconnecting in '
+            + delay
+            + 'ms (attempt '
+            + this.reconnectAttempts
+            + '/'
+            + this.options.maxReconnectAttempts
+            + ')');
+        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.
      */
-    async write(data) {
+    write(data) {
         return new Promise((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();
                 });
             }
         });
     }
     /**
-     * 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.
      */
     disconnect() {
+        try {
+            void this.disconnectAndWait().catch((error) => {
+                this.options.logger.log('error', 'Failed to disconnect socket transport: ' + this.getErrorMessage(error));
+            });
+        }
+        catch (error) {
+            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.
+     */
+    disconnectAndWait(_options = {}) {
         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;
+        const disconnectPromise = new Promise((resolve, reject) => {
+            rejectDisconnect = reject;
+            void generation.closePromise.then(resolve);
+        });
+        generation.disconnectPromise = disconnectPromise;
+        void disconnectPromise.then(() => { }, () => {
+            if (generation.disconnectPromise === disconnectPromise) {
+                generation.disconnectPromise = null;
+            }
+        });
+        // The close waiter above must exist before destroy() can cause 'close'.
+        try {
+            generation.socket.destroy();
+        }
+        catch (error) {
+            rejectDisconnect(this.toError(error, 'Failed to destroy local socket'));
+        }
+        return disconnectPromise;
+    }
+    cancelReconnectTimer() {
         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();
-        }
+    }
+    toError(error, prefix) {
+        return new Error(prefix + ': ' + this.getErrorMessage(error));
+    }
+    getErrorMessage(error) {
+        return error instanceof Error ? error.message : String(error);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.sockettransport.js","sourceRoot":"","sources":["../ts/classes.sockettransport.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.stdiotransport.d.ts

@@ -1,6 +1,6 @@
 import * as plugins from './plugins.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 IStdioTransportOptions {
     binaryPath: string;
     cliArgs: string[];
@@ -15,8 +15,8 @@ export interface IStdioTransportOptions {
 export declare class StdioTransport extends plugins.events.EventEmitter implements IRustTransport {
     private options;
     private childProcess;
+    private generation;
     private lineScanner;
-    private stderrRemainder;
     private _connected;
     constructor(options: IStdioTransportOptions);
     get connected(): boolean;
@@ -29,7 +29,19 @@ export declare class StdioTransport extends plugins.events.EventEmitter implemen
      */
     write(data: string): Promise<void>;
     /**
-     * Kill the child process. Sends SIGTERM, then SIGKILL after 5s.
+     * Kill the child process without waiting for confirmation.
      */
     disconnect(): void;
+    /**
+     * Send SIGTERM, escalate to SIGKILL after the grace period, and wait for
+     * ChildProcess 'close' to confirm termination.
+     */
+    disconnectAndWait(options?: IRustTransportDisconnectOptions): Promise<void>;
+    private scheduleForceKill;
+    private forceKill;
+    private sendSignal;
+    private hasExited;
+    private destroyOwnedStdioEndpoint;
+    private toError;
+    private getErrorMessage;
 }