@tmlmobilidade/ssh 20260709.1401.58 → 20260710.2205.51

package/dist/client.d.ts

@@ -0,0 +1,44 @@
+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 SshTunnelOptions {
+    maxRetries?: number;
+}
+export declare class SshTunnel {
+    private _server;
+    private config;
+    private options;
+    private retries;
+    constructor(config: SshConfig, options?: SshTunnelOptions);
+    get server(): Server | undefined;
+    /**
+     * 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 SshTunnel = new SshTunnel(config);
+     * SshTunnel.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/client.js

@@ -0,0 +1,88 @@
+/* * */
+import { Logger } from '@tmlmobilidade/logger';
+import { createTunnel } from 'tunnel-ssh';
+/* * */
+export class SshTunnel {
+    _server;
+    config;
+    options;
+    retries = 0;
+    constructor(config, options) {
+        this.config = config;
+        if (options)
+            this.options = options;
+    }
+    get server() {
+        return this._server;
+    }
+    /**
+     * 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 SshTunnel = new SshTunnel(config);
+     * SshTunnel.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({ message: `SSH Tunnel connected to host port ${server.address().port}` });
+            this._server = server;
+            server.on('error', (error) => {
+                Logger.error({ error, message: 'SSH Tunnel Error' });
+            });
+            server.on('close', () => {
+                Logger.info({ message: 'SSH Tunnel closed.' });
+            });
+            return this._server;
+        }
+        catch (error) {
+            if (error.code === 'EADDRINUSE') {
+                Logger.info({ message: `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({ error, message: 'Failed to connect to SSH Tunnel.' });
+                this.retries++;
+                Logger.info({ message: 'Retrying SSH connection...' });
+                return await this.connect();
+            }
+            else {
+                throw new Error('Error connecting to SSH tunnel', { cause: 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();
+        await this.connect();
+    }
+}

package/dist/index.d.ts

@@ -1,49 +1,3 @@
-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;
-    private _server;
-    private config;
-    private options;
-    private retries;
-    constructor(config: SshConfig, options?: SshTunnelServiceOptions);
-    get server(): Server | undefined;
-    /**
-     * 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>;
-}
+export * from './client.js';
+export * from './ssh.factory.js';
+export * from './tunnels.js';

package/dist/index.js

@@ -1,101 +1,3 @@
-/* * */
-import { Logger } from '@tmlmobilidade/logger';
-import { createTunnel } from 'tunnel-ssh';
-/* * */
-export class SshTunnelService {
-    static _instance;
-    _server;
-    config;
-    options;
-    retries = 0;
-    constructor(config, options) {
-        this.config = config;
-        if (options)
-            this.options = options;
-    }
-    get server() {
-        return this._server;
-    }
-    /**
-     * 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({ message: `SSH Tunnel connected to host port ${server.address().port}` });
-            this._server = server;
-            server.on('error', (error) => {
-                Logger.error({ error, message: 'SSH Tunnel Error' });
-            });
-            server.on('close', () => {
-                Logger.info({ message: 'SSH Tunnel closed.' });
-            });
-            return this._server;
-        }
-        catch (error) {
-            if (error.code === 'EADDRINUSE') {
-                Logger.info({ message: `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({ error, message: 'Failed to connect to SSH Tunnel.' });
-                this.retries++;
-                Logger.info({ message: '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();
-    }
-}
+export * from './client.js';
+export * from './ssh.factory.js';
+export * from './tunnels.js';

package/dist/ssh.factory.d.ts

@@ -0,0 +1,26 @@
+import { SshTunnel } from './client.js';
+type SshTunnelType = 'GO' | 'PCGI';
+interface SshTunnelFactoryOptions {
+    dstAddr: string;
+    dstPort: number;
+    maxRetries?: number;
+}
+export type SshTunnelFactory = (options: SshTunnelFactoryOptions) => null | SshTunnel;
+/**
+ * Creates an SSH tunnel factory for the given type.
+ *
+ * The returned function reads `{type}_TUNNEL_*` environment variables
+ * and builds an `SshTunnel` when tunneling is enabled.
+ *
+ * Expected environment variables:
+ *   `{type}_TUNNEL_ENABLED` — `"true"` or `"false"`; `"false"` returns `null`
+ *   `{type}_TUNNEL_SSH_HOST`
+ *   `{type}_TUNNEL_SSH_USERNAME`
+ *   `{type}_TUNNEL_SSH_KEY_PATH` (optional)
+ *   `{type}_TUNNEL_SSH_KEY` (optional)
+ *   `SSH_AUTH_SOCK` (optional fallback agent)
+ *
+ * Auth priority: `TUNNEL_SSH_KEY_PATH` > `TUNNEL_SSH_KEY` > `SSH_AUTH_SOCK`.
+ */
+export declare function createSshTunnelFactory(type: SshTunnelType): SshTunnelFactory;
+export {};

package/dist/ssh.factory.js

@@ -0,0 +1,75 @@
+/* * */
+import { randomInt } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { SshTunnel } from './client.js';
+/**
+ * Creates an SSH tunnel factory for the given type.
+ *
+ * The returned function reads `{type}_TUNNEL_*` environment variables
+ * and builds an `SshTunnel` when tunneling is enabled.
+ *
+ * Expected environment variables:
+ *   `{type}_TUNNEL_ENABLED` — `"true"` or `"false"`; `"false"` returns `null`
+ *   `{type}_TUNNEL_SSH_HOST`
+ *   `{type}_TUNNEL_SSH_USERNAME`
+ *   `{type}_TUNNEL_SSH_KEY_PATH` (optional)
+ *   `{type}_TUNNEL_SSH_KEY` (optional)
+ *   `SSH_AUTH_SOCK` (optional fallback agent)
+ *
+ * Auth priority: `TUNNEL_SSH_KEY_PATH` > `TUNNEL_SSH_KEY` > `SSH_AUTH_SOCK`.
+ */
+export function createSshTunnelFactory(type) {
+    return (options) => buildSshTunnel(type, options);
+}
+function buildSshTunnel(type, options) {
+    const { dstAddr, dstPort, maxRetries } = options;
+    const env = (name) => process.env[`${type}_${name}`];
+    if (env('TUNNEL_ENABLED') !== 'true' && env('TUNNEL_ENABLED') !== 'false') {
+        throw new Error(`Missing ${type}_TUNNEL_ENABLED. Please indicate whether SSH tunneling is required by setting ${type}_TUNNEL_ENABLED to "true" or "false".`);
+    }
+    if (env('TUNNEL_ENABLED') === 'false') {
+        return null;
+    }
+    if (!env('TUNNEL_SSH_HOST')) {
+        throw new Error(`Missing ${type}_TUNNEL_SSH_HOST environment variable.`);
+    }
+    if (!env('TUNNEL_SSH_USERNAME')) {
+        throw new Error(`Missing ${type}_TUNNEL_SSH_USERNAME environment variable.`);
+    }
+    if (!env('TUNNEL_SSH_KEY_PATH') && !env('TUNNEL_SSH_KEY') && !process.env.SSH_AUTH_SOCK) {
+        throw new Error(`Missing authentication configuration. Please provide ${type}_TUNNEL_SSH_KEY_PATH, ${type}_TUNNEL_SSH_KEY, or ensure SSH_AUTH_SOCK is set.`);
+    }
+    const srcPort = randomInt(8_000, 8_999);
+    const sshConfig = {
+        forwardOptions: {
+            dstAddr: dstAddr,
+            dstPort: dstPort,
+            srcAddr: 'localhost',
+            srcPort: srcPort,
+        },
+        serverOptions: {
+            port: srcPort,
+        },
+        sshOptions: {
+            agent: (env('TUNNEL_SSH_KEY_PATH') || env('TUNNEL_SSH_KEY')) ? undefined : process.env.SSH_AUTH_SOCK,
+            host: env('TUNNEL_SSH_HOST'),
+            keepaliveCountMax: 3,
+            keepaliveInterval: 10_000,
+            port: 22,
+            privateKey: env('TUNNEL_SSH_KEY_PATH')
+                ? readFileSync(env('TUNNEL_SSH_KEY_PATH'))
+                : env('TUNNEL_SSH_KEY')
+                    ? env('TUNNEL_SSH_KEY')
+                    : undefined,
+            username: env('TUNNEL_SSH_USERNAME'),
+        },
+        tunnelOptions: {
+            autoClose: false,
+            reconnectOnError: true,
+        },
+    };
+    const sshOptions = {
+        maxRetries: maxRetries ?? 3,
+    };
+    return new SshTunnel(sshConfig, sshOptions);
+}

package/dist/tunnels.d.ts

@@ -0,0 +1,2 @@
+export declare const goSshTunnel: import("./ssh.factory.js").SshTunnelFactory;
+export declare const pcgiSshTunnel: import("./ssh.factory.js").SshTunnelFactory;

package/dist/tunnels.js

@@ -0,0 +1,5 @@
+/* * */
+import { createSshTunnelFactory } from './ssh.factory.js';
+/* * */
+export const goSshTunnel = createSshTunnelFactory('GO');
+export const pcgiSshTunnel = createSshTunnelFactory('PCGI');

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tmlmobilidade/ssh",
-	"version": "20260709.1401.58",
+	"version": "20260710.2205.51",
 	"author": {
 		"email": "iso@tmlmobilidade.pt",
 		"name": "TML-ISO"