@syncbridge/pinggy 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/pinggy-tcp-client.component.d.ts

@@ -0,0 +1,34 @@
+import { Buffer } from 'node:buffer';
+import net from 'node:net';
+import { TunnelInstance } from '@pinggy/pinggy';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { PinggyTcpClientVariables } from './pinggy-tcp-client.variables.js';
+export declare class PinggyTcpClientComponent<TEvents extends PinggyTcpClientComponent.Events = PinggyTcpClientComponent.Events> extends IoClientBaseComponent<TEvents> {
+    readonly protocol: string;
+    protected _tunnel?: TunnelInstance;
+    protected _tunnelHealthcheckTimer?: NodeJS.Timeout;
+    protected _server?: net.Server;
+    protected _socket?: net.Socket;
+    protected _stopping?: boolean;
+    protected _reconnectTimer?: NodeJS.Timeout;
+    values: PinggyTcpClientVariables;
+    get connected(): boolean;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+    write(data: string | Buffer): void;
+}
+/**
+ /**
+ * @namespace
+ */
+export declare namespace PinggyTcpClientComponent {
+    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 PinggyTcpClientVariables;
+    type Variables = PinggyTcpClientVariables;
+}

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

@@ -0,0 +1,209 @@
+import { __decorate, __metadata } from "tslib";
+import net from 'node:net';
+import { clearInterval } from 'node:timers';
+import { pinggy } from '@pinggy/pinggy';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { Component, ServiceStatus } from '@syncbridge/common';
+import colors from 'ansi-colors';
+import { noOp } from '../constants.js';
+import { PinggyTcpClientVariables } from './pinggy-tcp-client.variables.js';
+let PinggyTcpClientComponent = class PinggyTcpClientComponent extends IoClientBaseComponent {
+    protocol = 'tcp';
+    _tunnel;
+    _tunnelHealthcheckTimer;
+    _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();
+        }
+        const onSocketData = (data) => {
+            this.emit('data', data);
+        };
+        const onSocketClose = () => {
+            this._socket = undefined;
+        };
+        let tries = 0;
+        const startLocalListener = 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 = 0;
+            }
+            catch (error) {
+                tries++;
+                error.message = `Can't create local listener. ${error?.message}`;
+                this.logger?.info(error.message +
+                    '\n' +
+                    `  Retry attempt (${colors.cyan(String(tries))}) will be made in ${colors.cyan('5 secs')}`);
+                this.setStatus(ServiceStatus.unhealthy, error.message);
+                this._reconnectTimer = setTimeout(() => {
+                    startLocalListener();
+                }, 5000);
+            }
+        };
+        /* */
+        const startTunnel = async () => {
+            /** Close previous tunnels */
+            if (this._tunnel) {
+                this.logger?.debug('Closing previous tunnel');
+                await this._tunnel.stop().catch(noOp);
+            }
+            this._tunnel = undefined;
+            const { port } = this._server.address();
+            /** Create the tunnel */
+            try {
+                this.logger?.debug(`Creating tcp tunnel`);
+                this._tunnel = await pinggy.forward({
+                    token: this.values.authToken,
+                    forwarding: 'tcp://localhost:' + port,
+                    autoReconnect: true,
+                    reconnectInterval: 5,
+                    maxReconnectAttempts: Number.MAX_SAFE_INTEGER,
+                });
+                tries = 0;
+                this._tunnel.setTunnelErrorCallback(payload => {
+                    const { errorNo, error, recoverable } = payload;
+                    const err = new Error(error);
+                    err.code = errorNo;
+                    err.recoverable = recoverable;
+                    this.emit('error', err);
+                    if (!recoverable) {
+                        setTimeout(() => {
+                            startTunnel().catch(noOp);
+                        }, 1000);
+                    }
+                });
+                const urls = await this._tunnel.urls();
+                this.logger?.info(`Tunnel started: tcp://${colors.blueBright(urls.join(', '))}`);
+            }
+            catch (err) {
+                tries++;
+                this.logger?.error(`Can't crate tunnel. ${err?.message}\n` +
+                    `  Retry attempt (${colors.cyan(String(tries))}) will be made in ${colors.cyan('5 secs')}`);
+                this._reconnectTimer = setTimeout(() => {
+                    startTunnel();
+                }, 5000);
+                return;
+            }
+        };
+        const tunnelHealthCheck = async () => {
+            // c8 ignore next
+            if (!this._tunnel)
+                return;
+            let lastStatus = await this._tunnel.getStatus();
+            this._tunnelHealthcheckTimer = setInterval(() => {
+                if (!this._tunnel) {
+                    clearInterval(this._tunnelHealthcheckTimer);
+                    return;
+                }
+                this._tunnel.getStatus()
+                    .then(async (status) => {
+                    if (status !== lastStatus) {
+                        lastStatus = status;
+                        await tunnelStatusChanged(status);
+                    }
+                })
+                    .catch(e => this.emit('error', e));
+            }, 100).unref();
+        };
+        /*  */
+        const tunnelStatusChanged = async (status) => {
+            if (status === 'closed') {
+                if (this._stopping)
+                    this.emit('disconnect');
+                else {
+                    const error = new Error('Tunnel disconnected');
+                    this.setStatus(ServiceStatus.unhealthy, error.message);
+                    this.emit('disconnect', error);
+                }
+                return;
+            }
+            if (status === 'live' && this._tunnel) {
+                tries = 0;
+                const urls = await this._tunnel.urls();
+                this.logger?.info(`Tunnel reconnected: ${colors.cyan(urls.join(', '))}`);
+                this.setStatus(ServiceStatus.started);
+                this.emit('connect');
+            }
+        };
+        startLocalListener()
+            .then(() => startTunnel())
+            .then(() => tunnelHealthCheck())
+            .catch(noOp);
+    }
+    async _stop() {
+        this._stopping = true;
+        clearInterval(this._tunnelHealthcheckTimer);
+        if (this._tunnel) {
+            this.logger?.debug('Disconnecting previous tunnel');
+            try {
+                await this._tunnel.stop();
+            }
+            catch (err) {
+                this.logger?.error(err);
+            }
+            this._tunnel = 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", PinggyTcpClientVariables)
+], PinggyTcpClientComponent.prototype, "values", void 0);
+PinggyTcpClientComponent = __decorate([
+    Component({
+        displayName: 'Pinggy Tcp Tunnel Client',
+        description: 'A Tcp client component which creates a tunnel using Pinggy (https://pinggy.io)',
+        tags: ['tcp', 'client', 'socket', 'connection', 'pinggy', 'tunnel'],
+    })
+], PinggyTcpClientComponent);
+export { PinggyTcpClientComponent };
+/**
+ /**
+ * @namespace
+ */
+(function (PinggyTcpClientComponent) {
+    PinggyTcpClientComponent.Variables = PinggyTcpClientVariables;
+})(PinggyTcpClientComponent || (PinggyTcpClientComponent = {}));
+/**
+ * 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);
+        });
+    });
+}

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

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

package/components/pinggy-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 PinggyTcpClientVariables extends IoClientBaseComponent.Variables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Pingy Auth Token',
+        type: VariableType.Secret,
+        description: 'Pingy auth token. https://dashboard.pinggy.io/managetokens',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], PinggyTcpClientVariables.prototype, "authToken", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Local Port',
+        description: 'Local port number which pinggy process connection to be served. If not set, a port number will be automatically selected',
+        default: 0,
+    }),
+    __metadata("design:type", Number)
+], PinggyTcpClientVariables.prototype, "localPort", void 0);

package/components.d.ts

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

package/components.js

@@ -0,0 +1 @@
+export * from './components/pinggy-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/pinggy",
+  "version": "0.4.1",
+  "description": "SyncBridge Pinggy component",
+  "author": "Panates Inc",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@pinggy/pinggy": "^0.3.2",
+    "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"
+  }
+}