@syncbridge/ngrok 0.4.1

package/LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2025 Panates (Panates Teknoloji Yatirim A.S.). All rights reserved.
+
+This software and associated documentation files (the "Software") are
+the proprietary property of Panates and are protected by copyright laws
+and international copyright treaties.
+
+Unauthorized copying, distribution, modification, reverse engineering,
+or use of this software, in whole or in part, is strictly prohibited
+without the express written permission of Panates.
+
+This Software is provided solely for use in accordance with the terms
+of a valid license agreement. Any unauthorized use may result in
+civil and/or criminal penalties.
+
+For licensing inquiries, please contact: info@panates.com

package/README.md

@@ -0,0 +1 @@
+# SyncBridge Ngrok Connectors

package/components/ngrok-tcp-client.component.d.ts

@@ -0,0 +1,33 @@
+import { Buffer } from 'node:buffer';
+import net from 'node:net';
+import ngrok from '@ngrok/ngrok';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { NgrokTcpClientVariables } from './ngrok-tcp-client.variables.js';
+export declare class NgrokTcpClientComponent<TEvents extends NgrokTcpClientComponent.Events = NgrokTcpClientComponent.Events> extends IoClientBaseComponent<TEvents> {
+    readonly protocol: string;
+    protected _ngrokListener?: ngrok.Listener;
+    protected _server?: net.Server;
+    protected _socket?: net.Socket;
+    protected _stopping?: boolean;
+    protected _reconnectTimer?: NodeJS.Timeout;
+    values: NgrokTcpClientVariables;
+    get connected(): boolean;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+    write(data: string | Buffer): void;
+}
+/**
+ /**
+ * @namespace
+ */
+export declare namespace NgrokTcpClientComponent {
+    interface Events extends IoClientBaseComponent.Events {
+        connect: [];
+        disconnect: [error: Error | undefined];
+        data: [data: Buffer];
+        reconnecting: [n: number, delay: number];
+        write: [data: Buffer | string];
+    }
+    const Variables: typeof NgrokTcpClientVariables;
+    type Variables = NgrokTcpClientVariables;
+}

package/components/ngrok-tcp-client.component.js

@@ -0,0 +1,202 @@
+import { __decorate, __metadata } from "tslib";
+import net from 'node:net';
+import ngrok from '@ngrok/ngrok';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { Component, ServiceStatus } from '@syncbridge/common';
+import colors from 'ansi-colors';
+import { splitString } from 'fast-tokenizer';
+import { noOp } from '../constants.js';
+import { NgrokTcpClientVariables } from './ngrok-tcp-client.variables.js';
+let NgrokTcpClientComponent = class NgrokTcpClientComponent extends IoClientBaseComponent {
+    protocol = 'tcp';
+    _ngrokListener;
+    _server;
+    _socket;
+    _stopping;
+    _reconnectTimer;
+    get connected() {
+        return !!this._socket;
+    }
+    async _start(abortSignal) {
+        await super._start(abortSignal);
+        this._stopping = false;
+        if (this._server) {
+            this._server.close();
+        }
+        let tries = -1;
+        const onSocketData = (data) => {
+            this.emit('data', data);
+        };
+        const onSocketClose = () => {
+            this._socket = undefined;
+        };
+        const startServer = async () => {
+            try {
+                this.logger?.debug(`Creating local listener`);
+                this._server = await createServer(this.values.localPort, socket => {
+                    // The last connected socket is ngok agent, we will use it to read and write operations
+                    if (this._socket) {
+                        this._socket.off('data', onSocketData);
+                        this._socket.off('close', onSocketClose);
+                    }
+                    this._socket = socket;
+                    socket.on('data', onSocketData);
+                    socket.on('close', onSocketClose);
+                }).catch(noOp);
+                tries = -1;
+            }
+            catch (error) {
+                tries++;
+                error.message = `Can't create local listener. ${error?.message}`;
+                this.logger?.info(error.message +
+                    '\n' +
+                    `  Retry attempt (${colors.cyan(String(tries + 1))}) will be made in ${colors.cyan('5 secs')}`);
+                this.setStatus(ServiceStatus.unhealthy, error.message);
+                this._reconnectTimer = setTimeout(() => {
+                    startServer();
+                }, 5000);
+            }
+        };
+        /*  */
+        const _ngrokStatusChange = (status) => {
+            if (status === 'closed') {
+                if (this._stopping)
+                    this.emit('disconnect');
+                else {
+                    const error = new Error('Ngrok tunnel disconnected');
+                    this.setStatus(ServiceStatus.unhealthy, error.message);
+                    this.emit('disconnect', error);
+                }
+                return;
+            }
+            if (status === 'connected') {
+                tries = -1;
+                if (this._ngrokListener) {
+                    this.logger?.info(`Ngrok tunnel reconnected: ${colors.cyan(this._ngrokListener.url())}`);
+                }
+                this.setStatus(ServiceStatus.started);
+                this.emit('connect');
+            }
+        };
+        /*  */
+        const _ngrokLogEvent = (event) => {
+            if (this._stopping)
+                return;
+            const log = parseNgrokLog(event);
+            if (log.msg?.includes(' not yet '))
+                return;
+            if (log.lvl === 'warn') {
+                if (log.err)
+                    this.logger?.error(log.err);
+            }
+            else if (log.lvl === 'error') {
+                this.logger?.error(log.msg);
+            }
+            else
+                this.logger?.debug(`lvl=${log.lvl} | ${log.msg}`);
+        };
+        /* */
+        const startNgrok = async () => {
+            this.logger?.trace('Starting Ngrok tunnel');
+            /** Close previous tunnels */
+            if (this._ngrokListener) {
+                this.logger?.debug('Disconnecting previous tunnel');
+                await this._ngrokListener.close();
+            }
+            this._ngrokListener = undefined;
+            const { port } = this._server.address();
+            /** Create tunnel */
+            try {
+                this.logger?.debug(`Creating Ngrok tunnel`);
+                this._ngrokListener = await ngrok.forward({
+                    proto: 'tcp',
+                    authtoken: this.values.authToken,
+                    addr: port,
+                    onStatusChange: _ngrokStatusChange,
+                    onLogEvent: _ngrokLogEvent,
+                });
+                this.logger?.info(`Ngrok tunnel connected: ${colors.blueBright(this._ngrokListener.url())}`);
+            }
+            catch (err) {
+                tries++;
+                this.logger?.error(`Can't crate Ngrok tunnel. ${err?.message}\n` +
+                    `  Retry attempt (${colors.cyan(String(tries))}) will be made in ${colors.cyan('5 secs')}`);
+                this._reconnectTimer = setTimeout(() => {
+                    startNgrok();
+                }, 5000);
+                return;
+            }
+        };
+        startServer()
+            .then(() => startNgrok())
+            .catch(noOp);
+    }
+    async _stop() {
+        this._stopping = true;
+        if (this._ngrokListener) {
+            this.logger?.debug('Disconnecting previous tunnel');
+            await this._ngrokListener.close().catch(noOp);
+            this._ngrokListener = undefined;
+        }
+        if (this._server?.listening) {
+            await new Promise(resolve => {
+                this._server.close(() => resolve());
+            }).catch(noOp);
+            this._server = undefined;
+        }
+    }
+    write(data) {
+        if (!this.connected) {
+            throw new Error(`Can't write while TCP socket is not connected`);
+        }
+        this.emit('write', data);
+        this._socket?.write(data);
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", NgrokTcpClientVariables)
+], NgrokTcpClientComponent.prototype, "values", void 0);
+NgrokTcpClientComponent = __decorate([
+    Component({
+        displayName: 'Ngrok TCP Client Tunnel',
+        description: 'Tcp client tunnel for Ngrok (https://ngrok.com)',
+        tags: ['tcp', 'client', 'socket', 'connection', 'ngrok'],
+    })
+], NgrokTcpClientComponent);
+export { NgrokTcpClientComponent };
+/**
+ /**
+ * @namespace
+ */
+(function (NgrokTcpClientComponent) {
+    NgrokTcpClientComponent.Variables = NgrokTcpClientVariables;
+})(NgrokTcpClientComponent || (NgrokTcpClientComponent = {}));
+/**
+ * Creates and initializes a server instance on the first available port within the specified range.
+ */
+function createServer(port = 0, connectionListener) {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer(connectionListener);
+        server.on('error', reject);
+        server.listen(port, '127.0.0.1', () => {
+            resolve(server);
+        });
+    });
+}
+function parseNgrokLog(line) {
+    const splitted = splitString(line, {
+        delimiters: ' ',
+        keepQuotes: true,
+        quotes: true,
+    });
+    return splitted.reduce((a, s) => {
+        const v = splitString(s, {
+            delimiters: '=',
+            keepQuotes: false,
+            quotes: true,
+        });
+        a[v[0]] = v[1];
+        return a;
+    }, {});
+}

package/components/ngrok-tcp-client.variables.d.ts

@@ -0,0 +1,8 @@
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+/**
+ * Variables
+ */
+export declare class NgrokTcpClientVariables extends IoClientBaseComponent.Variables {
+    authToken: string;
+    localPort: number;
+}

package/components/ngrok-tcp-client.variables.js

@@ -0,0 +1,25 @@
+import { __decorate, __metadata } from "tslib";
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { DefineVariable, VariableType } from '@syncbridge/common';
+/**
+ * Variables
+ */
+export class NgrokTcpClientVariables extends IoClientBaseComponent.Variables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Ngrok Auth Token',
+        type: VariableType.Secret,
+        description: 'Ngrok auth token',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], NgrokTcpClientVariables.prototype, "authToken", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Local Port',
+        description: 'Local port number which ngrok process connection to be served. If not set, a port number will be automatically selected',
+        default: 0,
+    }),
+    __metadata("design:type", Number)
+], NgrokTcpClientVariables.prototype, "localPort", void 0);

package/components.d.ts

@@ -0,0 +1 @@
+export * from './components/ngrok-tcp-client.component.js';

package/components.js

@@ -0,0 +1 @@
+export * from './components/ngrok-tcp-client.component.js';

package/constants.d.ts

@@ -0,0 +1,4 @@
+import { AuthorMetadata } from '@syncbridge/common';
+export declare const version = "1";
+export declare const noOp: () => undefined;
+export declare const panatesAuthor: AuthorMetadata;

package/constants.js

@@ -0,0 +1,7 @@
+export const version = '0.4.1';
+export const noOp = () => undefined;
+export const panatesAuthor = {
+    name: 'Panates Technology AS',
+    email: 'info@panates.com',
+    url: 'https://www.panates.com',
+};

package/index.d.ts

@@ -0,0 +1,5 @@
+import * as components from './components.js';
+export { components };
+export * from './components.js';
+declare const cfg: import("@syncbridge/common").IExtensionPackage;
+export default cfg;

package/index.js

@@ -0,0 +1,9 @@
+import { makeExtensionPackage } from '@syncbridge/common';
+import * as components from './components.js';
+export { components };
+export * from './components.js';
+const cfg = makeExtensionPackage({
+    processors: [],
+    components: Object.values(components),
+});
+export default cfg;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@syncbridge/ngrok",
+  "version": "0.4.1",
+  "description": "SyncBridge Ngrok component",
+  "author": "Panates Inc",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@ngrok/ngrok": "^1.7.0",
+    "ansi-colors": "^4.1.3",
+    "fast-tokenizer": "^1.9.0",
+    "node-events-async": "^1.5.0"
+  },
+  "peerDependencies": {
+    "@syncbridge/common": "^0.4.1",
+    "@syncbridge/builtins": "^0.4.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}