@tmlmobilidade/ssh 20251202.1817.5

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+import { type Server } from 'node:net';
+import { type ForwardOptions, type ServerOptions, type SshOptions, type TunnelOptions } from 'tunnel-ssh';
+export interface SshConfig {
+    forwardOptions: ForwardOptions;
+    serverOptions: ServerOptions;
+    sshOptions: SshOptions;
+    tunnelOptions: TunnelOptions;
+}
+export interface SshTunnelServiceOptions {
+    maxRetries?: number;
+}
+export declare class SshTunnelService {
+    private static _instance;
+    get server(): Server | undefined;
+    private _server;
+    private config;
+    private options;
+    private retries;
+    constructor(config: SshConfig, options?: SshTunnelServiceOptions);
+    /**
+     * Get the singleton instance of SshTunnelService.
+     */
+    static getInstance(config?: SshConfig, options?: SshTunnelServiceOptions): SshTunnelService;
+    /**
+     * Establishes an SSH tunnel connection using the provided configuration options.
+     * @throws Throws an error if the connection fails after the maximum number of retries.
+     * @remarks
+     * - The method attempts to create an SSH tunnel using the `createTunnel` function with the specified options.
+     * - If the connection is successful, it logs the connected host port and sets up an error listener on the server.
+     * - If the connection fails, it retries the connection up to a maximum number of retries specified in the options.
+     * @example ```typescript
+     * const sshTunnelService = new SshTunnelService(config);
+     * sshTunnelService.connect();
+     * ```
+     */
+    connect(): any;
+    /**
+     * Disconnects the SSH tunnel by closing the server.
+     * @returns A promise that resolves when the server is successfully closed.
+     * @throws Will log an error message if the server fails to close.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Reconnects the SSH tunnel by first disconnecting and then connecting again.
+     * This method ensures that the connection is reset.
+     * @returns A promise that resolves when the reconnection process is complete.
+     */
+    reconnect(): Promise<void>;
+}

package/dist/index.js

@@ -0,0 +1,101 @@
+/* * */
+import { Logger } from '@tmlmobilidade/logger';
+import { createTunnel } from 'tunnel-ssh';
+/* * */
+export class SshTunnelService {
+    static _instance;
+    get server() {
+        return this._server;
+    }
+    _server;
+    config;
+    options;
+    retries = 0;
+    constructor(config, options) {
+        this.config = config;
+        if (options)
+            this.options = options;
+    }
+    /**
+     * Get the singleton instance of SshTunnelService.
+     */
+    static getInstance(config, options) {
+        if (!SshTunnelService._instance) {
+            if (!config) {
+                throw new Error('SSH Config is required');
+            }
+            SshTunnelService._instance = new SshTunnelService(config, options);
+        }
+        return SshTunnelService._instance;
+    }
+    /**
+     * Establishes an SSH tunnel connection using the provided configuration options.
+     * @throws Throws an error if the connection fails after the maximum number of retries.
+     * @remarks
+     * - The method attempts to create an SSH tunnel using the `createTunnel` function with the specified options.
+     * - If the connection is successful, it logs the connected host port and sets up an error listener on the server.
+     * - If the connection fails, it retries the connection up to a maximum number of retries specified in the options.
+     * @example ```typescript
+     * const sshTunnelService = new SshTunnelService(config);
+     * sshTunnelService.connect();
+     * ```
+     */
+    async connect() {
+        try {
+            if (this._server) {
+                // If the server is already connected, return it
+                console.log(`⤷ SSH Tunnel already connected.`);
+                return this._server;
+            }
+            const [server] = await createTunnel(this.config.tunnelOptions, this.config.serverOptions, this.config.sshOptions, this.config.forwardOptions);
+            Logger.info(`SSH Tunnel connected to host port ${server.address().port}`);
+            this._server = server;
+            server.on('error', (error) => {
+                Logger.error(`SSH Tunnel Error`, error);
+            });
+            server.on('close', () => {
+                Logger.info('SSH Tunnel closed.');
+            });
+            return this._server;
+        }
+        catch (error) {
+            if (error.code === 'EADDRINUSE') {
+                Logger.info(`Port "${this.config.serverOptions.port}" already in use. Retrying with a different port...`);
+                this.config.serverOptions.port++;
+                return await this.connect();
+            }
+            else if (this.retries < (this.options?.maxRetries || 3)) {
+                Logger.error(`Failed to connect to SSH Tunnel.`, error);
+                this.retries++;
+                Logger.info('Retrying SSH connection...');
+                return await this.connect();
+            }
+            else {
+                throw new Error('Error connecting to SSH tunnel', error);
+            }
+        }
+    }
+    /**
+     * Disconnects the SSH tunnel by closing the server.
+     * @returns A promise that resolves when the server is successfully closed.
+     * @throws Will log an error message if the server fails to close.
+     */
+    async disconnect() {
+        try {
+            this._server.close();
+            console.log(`⤷ SSH Tunnel disconnected.`);
+        }
+        catch (error) {
+            console.log(`⤷ ERROR: Failed to disconnect from SSH Tunnel.`, error);
+        }
+    }
+    /**
+     * Reconnects the SSH tunnel by first disconnecting and then connecting again.
+     * This method ensures that the connection is reset.
+     * @returns A promise that resolves when the reconnection process is complete.
+     */
+    async reconnect() {
+        await this.disconnect();
+        this.connect();
+    }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+	"name": "@tmlmobilidade/ssh",
+	"version": "20251202.1817.5",
+	"author": {
+		"email": "iso@tmlmobilidade.pt",
+		"name": "TML-ISO"
+	},
+	"license": "AGPL-3.0-or-later",
+	"homepage": "https://github.com/tmlmobilidade/go#readme",
+	"bugs": {
+		"url": "https://github.com/tmlmobilidade/go/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/tmlmobilidade/go.git"
+	},
+	"keywords": [
+		"public transit",
+		"tml",
+		"transportes metropolitanos de lisboa",
+		"go"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"files": [
+		"dist"
+	],
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"scripts": {
+		"build": "tsc && resolve-tspaths",
+		"lint": "eslint ./src/ && tsc --noEmit",
+		"lint:fix": "eslint ./src/ --fix",
+		"watch": "tsc-watch --onSuccess 'resolve-tspaths'"
+	},
+	"dependencies": {
+		"@tmlmobilidade/logger": "*",
+		"tunnel-ssh": "5.2.0"
+	},
+	"devDependencies": {
+		"@tmlmobilidade/tsconfig": "*",
+		"@types/node": "24.10.1",
+		"resolve-tspaths": "0.8.23",
+		"tsc-watch": "7.2.0",
+		"typescript": "5.9.3"
+	}
+}