@serve.zone/remoteingress 1.0.4 → 3.0.0

package/dist_ts/00_commitinfo_data.d.ts

@@ -1,5 +1,5 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export declare const commitinfo: {
     name: string;

package/dist_ts/00_commitinfo_data.js

@@ -1,9 +1,9 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
     name: '@serve.zone/remoteingress',
-    version: '1.0.4',
-    description: 'Provides a service for creating private tunnels and reaching private clusters from the outside, facilitating secure remote access as part of the @serve.zone stack.'
+    version: '3.0.0',
+    description: 'Edge ingress tunnel for DcRouter - accepts incoming TCP connections at network edge and tunnels them to DcRouter SmartProxy preserving client IP via PROXY protocol v1.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwyQkFBMkI7SUFDakMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHFLQUFxSztDQUNuTCxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwyQkFBMkI7SUFDakMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHlLQUF5SztDQUN2TCxDQUFBIn0=

package/dist_ts/classes.remoteingressedge.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from 'events';
+export interface IEdgeConfig {
+    hubHost: string;
+    hubPort?: number;
+    edgeId: string;
+    secret: string;
+    listenPorts: number[];
+    stunIntervalSecs?: number;
+}
+export declare class RemoteIngressEdge extends EventEmitter {
+    private bridge;
+    private started;
+    constructor();
+    /**
+     * Start the edge — spawns the Rust binary and connects to the hub.
+     */
+    start(config: IEdgeConfig): Promise<void>;
+    /**
+     * Stop the edge and kill the Rust process.
+     */
+    stop(): Promise<void>;
+    /**
+     * Get the current edge status.
+     */
+    getStatus(): Promise<{
+        running: boolean;
+        connected: boolean;
+        publicIp: string | null;
+        activeStreams: number;
+        listenPorts: number[];
+    }>;
+    /**
+     * Check if the bridge is running.
+     */
+    get running(): boolean;
+}

package/dist_ts/classes.remoteingressedge.js

@@ -0,0 +1,77 @@
+import * as plugins from './plugins.js';
+import { EventEmitter } from 'events';
+export class RemoteIngressEdge extends EventEmitter {
+    constructor() {
+        super();
+        this.started = false;
+        const packageDir = plugins.path.resolve(plugins.path.dirname(new URL(import.meta.url).pathname), '..');
+        this.bridge = new plugins.smartrust.RustBridge({
+            binaryName: 'remoteingress-bin',
+            cliArgs: ['--management'],
+            requestTimeoutMs: 30_000,
+            readyTimeoutMs: 10_000,
+            localPaths: [
+                plugins.path.join(packageDir, 'dist_rust'),
+                plugins.path.join(packageDir, 'rust', 'target', 'release'),
+                plugins.path.join(packageDir, 'rust', 'target', 'debug'),
+            ],
+            searchSystemPath: false,
+        });
+        // Forward events from Rust binary
+        this.bridge.on('management:tunnelConnected', () => {
+            this.emit('tunnelConnected');
+        });
+        this.bridge.on('management:tunnelDisconnected', () => {
+            this.emit('tunnelDisconnected');
+        });
+        this.bridge.on('management:publicIpDiscovered', (data) => {
+            this.emit('publicIpDiscovered', data);
+        });
+    }
+    /**
+     * Start the edge — spawns the Rust binary and connects to the hub.
+     */
+    async start(config) {
+        const spawned = await this.bridge.spawn();
+        if (!spawned) {
+            throw new Error('Failed to spawn remoteingress-bin');
+        }
+        await this.bridge.sendCommand('startEdge', {
+            hubHost: config.hubHost,
+            hubPort: config.hubPort ?? 8443,
+            edgeId: config.edgeId,
+            secret: config.secret,
+            listenPorts: config.listenPorts,
+            stunIntervalSecs: config.stunIntervalSecs,
+        });
+        this.started = true;
+    }
+    /**
+     * Stop the edge and kill the Rust process.
+     */
+    async stop() {
+        if (this.started) {
+            try {
+                await this.bridge.sendCommand('stopEdge', {});
+            }
+            catch {
+                // Process may already be dead
+            }
+            this.bridge.kill();
+            this.started = false;
+        }
+    }
+    /**
+     * Get the current edge status.
+     */
+    async getStatus() {
+        return this.bridge.sendCommand('getEdgeStatus', {});
+    }
+    /**
+     * Check if the bridge is running.
+     */
+    get running() {
+        return this.bridge.running;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.remoteingresshub.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'events';
+export interface IHubConfig {
+    tunnelPort?: number;
+    targetHost?: string;
+}
+export declare class RemoteIngressHub extends EventEmitter {
+    private bridge;
+    private started;
+    constructor();
+    /**
+     * Start the hub — spawns the Rust binary and starts the tunnel server.
+     */
+    start(config?: IHubConfig): Promise<void>;
+    /**
+     * Stop the hub and kill the Rust process.
+     */
+    stop(): Promise<void>;
+    /**
+     * Update the list of allowed edges that can connect to this hub.
+     */
+    updateAllowedEdges(edges: Array<{
+        id: string;
+        secret: string;
+    }>): Promise<void>;
+    /**
+     * Get the current hub status.
+     */
+    getStatus(): Promise<{
+        running: boolean;
+        tunnelPort: number;
+        connectedEdges: Array<{
+            edgeId: string;
+            connectedAt: number;
+            activeStreams: number;
+        }>;
+    }>;
+    /**
+     * Check if the bridge is running.
+     */
+    get running(): boolean;
+}

package/dist_ts/classes.remoteingresshub.js

@@ -0,0 +1,82 @@
+import * as plugins from './plugins.js';
+import { EventEmitter } from 'events';
+export class RemoteIngressHub extends EventEmitter {
+    constructor() {
+        super();
+        this.started = false;
+        const packageDir = plugins.path.resolve(plugins.path.dirname(new URL(import.meta.url).pathname), '..');
+        this.bridge = new plugins.smartrust.RustBridge({
+            binaryName: 'remoteingress-bin',
+            cliArgs: ['--management'],
+            requestTimeoutMs: 30_000,
+            readyTimeoutMs: 10_000,
+            localPaths: [
+                plugins.path.join(packageDir, 'dist_rust'),
+                plugins.path.join(packageDir, 'rust', 'target', 'release'),
+                plugins.path.join(packageDir, 'rust', 'target', 'debug'),
+            ],
+            searchSystemPath: false,
+        });
+        // Forward events from Rust binary
+        this.bridge.on('management:edgeConnected', (data) => {
+            this.emit('edgeConnected', data);
+        });
+        this.bridge.on('management:edgeDisconnected', (data) => {
+            this.emit('edgeDisconnected', data);
+        });
+        this.bridge.on('management:streamOpened', (data) => {
+            this.emit('streamOpened', data);
+        });
+        this.bridge.on('management:streamClosed', (data) => {
+            this.emit('streamClosed', data);
+        });
+    }
+    /**
+     * Start the hub — spawns the Rust binary and starts the tunnel server.
+     */
+    async start(config = {}) {
+        const spawned = await this.bridge.spawn();
+        if (!spawned) {
+            throw new Error('Failed to spawn remoteingress-bin');
+        }
+        await this.bridge.sendCommand('startHub', {
+            tunnelPort: config.tunnelPort ?? 8443,
+            targetHost: config.targetHost ?? '127.0.0.1',
+        });
+        this.started = true;
+    }
+    /**
+     * Stop the hub and kill the Rust process.
+     */
+    async stop() {
+        if (this.started) {
+            try {
+                await this.bridge.sendCommand('stopHub', {});
+            }
+            catch {
+                // Process may already be dead
+            }
+            this.bridge.kill();
+            this.started = false;
+        }
+    }
+    /**
+     * Update the list of allowed edges that can connect to this hub.
+     */
+    async updateAllowedEdges(edges) {
+        await this.bridge.sendCommand('updateAllowedEdges', { edges });
+    }
+    /**
+     * Get the current hub status.
+     */
+    async getStatus() {
+        return this.bridge.sendCommand('getHubStatus', {});
+    }
+    /**
+     * Check if the bridge is running.
+     */
+    get running() {
+        return this.bridge.running;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -1,4 +1,2 @@
-import { ConnectorPublic } from './connector.public.js';
-import { ConnectorPrivate } from './connector.private.js';
-export { ConnectorPublic, ConnectorPrivate };
-export declare const runCli: () => Promise<void>;
+export * from './classes.remoteingresshub.js';
+export * from './classes.remoteingressedge.js';

package/dist_ts/index.js

@@ -1,9 +1,3 @@
-import * as plugins from './plugins.js';
-import { ConnectorPublic } from './connector.public.js';
-import { ConnectorPrivate } from './connector.private.js';
-export { ConnectorPublic, ConnectorPrivate };
-export const runCli = async () => {
-    const qenv = new plugins.qenv.Qenv();
-    const mode = await qenv.getEnvVarOnDemand('MODE');
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4QyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFMUQsT0FBTyxFQUNMLGVBQWUsRUFDZixnQkFBZ0IsRUFDakIsQ0FBQTtBQUVELE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxLQUFLLElBQUksRUFBRTtJQUMvQixNQUFNLElBQUksR0FBRyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDckMsTUFBTSxJQUFJLEdBQUcsTUFBTSxJQUFJLENBQUMsaUJBQWlCLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDcEQsQ0FBQyxDQUFBIn0=
+export * from './classes.remoteingresshub.js';
+export * from './classes.remoteingressedge.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsZ0NBQWdDLENBQUMifQ==

package/dist_ts/plugins.d.ts

@@ -1,7 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import * as tls from 'tls';
-import * as fs from 'fs';
-export { tls, fs, };
-import * as qenv from '@push.rocks/qenv';
-export { qenv, };
+import * as path from 'path';
+export { path };
+import * as smartrust from '@push.rocks/smartrust';
+export { smartrust };

package/dist_ts/plugins.js

@@ -1,8 +1,7 @@
 // node native scope
-import * as tls from 'tls';
-import * as fs from 'fs';
-export { tls, fs, };
+import * as path from 'path';
+export { path };
 // @push.rocks scope
-import * as qenv from '@push.rocks/qenv';
-export { qenv, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBRXpCLE9BQU8sRUFDTCxHQUFHLEVBQ0gsRUFBRSxHQUNILENBQUE7QUFFRCxvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLElBQUksTUFBTSxrQkFBa0IsQ0FBQztBQUV6QyxPQUFPLEVBQ0wsSUFBSSxHQUNMLENBQUEifQ==
+import * as smartrust from '@push.rocks/smartrust';
+export { smartrust };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUVoQixvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsU0FBUyxFQUFFLENBQUMifQ==

package/npmextra.json

@@ -1,5 +1,11 @@
 {
-  "gitzone": {
+  "@git.zone/tsrust": {
+    "targets": [
+      "linux_amd64",
+      "linux_arm64"
+    ]
+  },
+  "@git.zone/cli": {
     "projectType": "npm",
     "module": {
       "githost": "code.foss.global",
@@ -26,13 +32,19 @@
         "software development",
         "private network integration"
       ]
+    },
+    "release": {
+      "registries": [
+        "https://verdaccio.lossless.digital",
+        "https://registry.npmjs.org"
+      ],
+      "accessLevel": "public"
     }
   },
-  "npmci": {
-    "npmGlobalTools": [],
-    "npmAccessLevel": "public"
-  },
-  "tsdoc": {
+  "@git.zone/tsdoc": {
     "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  },
+  "@ship.zone/szci": {
+    "npmGlobalTools": []
   }
 }

package/package.json

@@ -1,23 +1,30 @@
 {
   "name": "@serve.zone/remoteingress",
-  "version": "1.0.4",
+  "version": "3.0.0",
   "private": false,
-  "description": "Provides a service for creating private tunnels and reaching private clusters from the outside, facilitating secure remote access as part of the @serve.zone stack.",
+  "description": "Edge ingress tunnel for DcRouter - accepts incoming TCP connections at network edge and tunnels them to DcRouter SmartProxy preserving client IP via PROXY protocol v1.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
+  "scripts": {
+    "test": "(tstest test/ --web)",
+    "build": "(tsbuild --web --allowimplicitany && tsrust)",
+    "buildDocs": "(tsdoc)"
+  },
   "devDependencies": {
     "@git.zone/tsbuild": "^2.1.25",
     "@git.zone/tsbundle": "^2.0.5",
     "@git.zone/tsrun": "^1.2.46",
+    "@git.zone/tsrust": "^1.3.0",
     "@git.zone/tstest": "^1.0.44",
     "@push.rocks/tapbundle": "^5.0.15",
     "@types/node": "^20.8.7"
   },
   "dependencies": {
-    "@push.rocks/qenv": "^6.0.5"
+    "@push.rocks/qenv": "^6.0.5",
+    "@push.rocks/smartrust": "^1.2.1"
   },
   "repository": {
     "type": "git",
@@ -37,6 +44,7 @@
     "dist_*/**/*",
     "dist_ts/**/*",
     "dist_ts_web/**/*",
+    "dist_rust/**/*",
     "assets/**/*",
     "cli.js",
     "npmextra.json",
@@ -44,24 +52,15 @@
   ],
   "keywords": [
     "remote access",
-    "private tunnels",
-    "network security",
-    "TLS encryption",
-    "connector",
+    "ingress tunnel",
+    "network edge",
+    "PROXY protocol",
+    "multiplexed tunnel",
+    "TCP proxy",
+    "TLS tunnel",
     "serve.zone stack",
-    "private clusters access",
-    "public access management",
-    "TypeScript application",
-    "node.js package",
-    "secure communications",
-    "TLS/SSL certificates",
-    "development tools",
-    "software development",
-    "private network integration"
-  ],
-  "scripts": {
-    "test": "(tstest test/ --web)",
-    "build": "(tsbuild --web --allowimplicitany)",
-    "buildDocs": "(tsdoc)"
-  }
-}
+    "TypeScript",
+    "Rust",
+    "SmartProxy"
+  ]
+}

package/ts/00_commitinfo_data.ts

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@serve.zone/remoteingress',
-  version: '1.0.4',
-  description: 'Provides a service for creating private tunnels and reaching private clusters from the outside, facilitating secure remote access as part of the @serve.zone stack.'
+  version: '3.0.0',
+  description: 'Edge ingress tunnel for DcRouter - accepts incoming TCP connections at network edge and tunnels them to DcRouter SmartProxy preserving client IP via PROXY protocol v1.'
 }

package/ts/classes.remoteingressedge.ts

@@ -0,0 +1,132 @@
+import * as plugins from './plugins.js';
+import { EventEmitter } from 'events';
+
+// Command map for the edge side of remoteingress-bin
+type TEdgeCommands = {
+  ping: {
+    params: Record<string, never>;
+    result: { pong: boolean };
+  };
+  startEdge: {
+    params: {
+      hubHost: string;
+      hubPort: number;
+      edgeId: string;
+      secret: string;
+      listenPorts: number[];
+      stunIntervalSecs?: number;
+    };
+    result: { started: boolean };
+  };
+  stopEdge: {
+    params: Record<string, never>;
+    result: { stopped: boolean; wasRunning?: boolean };
+  };
+  getEdgeStatus: {
+    params: Record<string, never>;
+    result: {
+      running: boolean;
+      connected: boolean;
+      publicIp: string | null;
+      activeStreams: number;
+      listenPorts: number[];
+    };
+  };
+};
+
+export interface IEdgeConfig {
+  hubHost: string;
+  hubPort?: number;
+  edgeId: string;
+  secret: string;
+  listenPorts: number[];
+  stunIntervalSecs?: number;
+}
+
+export class RemoteIngressEdge extends EventEmitter {
+  private bridge: InstanceType<typeof plugins.smartrust.RustBridge<TEdgeCommands>>;
+  private started = false;
+
+  constructor() {
+    super();
+
+    const packageDir = plugins.path.resolve(
+      plugins.path.dirname(new URL(import.meta.url).pathname),
+      '..',
+    );
+
+    this.bridge = new plugins.smartrust.RustBridge<TEdgeCommands>({
+      binaryName: 'remoteingress-bin',
+      cliArgs: ['--management'],
+      requestTimeoutMs: 30_000,
+      readyTimeoutMs: 10_000,
+      localPaths: [
+        plugins.path.join(packageDir, 'dist_rust'),
+        plugins.path.join(packageDir, 'rust', 'target', 'release'),
+        plugins.path.join(packageDir, 'rust', 'target', 'debug'),
+      ],
+      searchSystemPath: false,
+    });
+
+    // Forward events from Rust binary
+    this.bridge.on('management:tunnelConnected', () => {
+      this.emit('tunnelConnected');
+    });
+    this.bridge.on('management:tunnelDisconnected', () => {
+      this.emit('tunnelDisconnected');
+    });
+    this.bridge.on('management:publicIpDiscovered', (data: { ip: string }) => {
+      this.emit('publicIpDiscovered', data);
+    });
+  }
+
+  /**
+   * Start the edge — spawns the Rust binary and connects to the hub.
+   */
+  public async start(config: IEdgeConfig): Promise<void> {
+    const spawned = await this.bridge.spawn();
+    if (!spawned) {
+      throw new Error('Failed to spawn remoteingress-bin');
+    }
+
+    await this.bridge.sendCommand('startEdge', {
+      hubHost: config.hubHost,
+      hubPort: config.hubPort ?? 8443,
+      edgeId: config.edgeId,
+      secret: config.secret,
+      listenPorts: config.listenPorts,
+      stunIntervalSecs: config.stunIntervalSecs,
+    });
+
+    this.started = true;
+  }
+
+  /**
+   * Stop the edge and kill the Rust process.
+   */
+  public async stop(): Promise<void> {
+    if (this.started) {
+      try {
+        await this.bridge.sendCommand('stopEdge', {} as Record<string, never>);
+      } catch {
+        // Process may already be dead
+      }
+      this.bridge.kill();
+      this.started = false;
+    }
+  }
+
+  /**
+   * Get the current edge status.
+   */
+  public async getStatus() {
+    return this.bridge.sendCommand('getEdgeStatus', {} as Record<string, never>);
+  }
+
+  /**
+   * Check if the bridge is running.
+   */
+  public get running(): boolean {
+    return this.bridge.running;
+  }
+}

package/ts/classes.remoteingresshub.ts

@@ -0,0 +1,138 @@
+import * as plugins from './plugins.js';
+import { EventEmitter } from 'events';
+
+// Command map for the hub side of remoteingress-bin
+type THubCommands = {
+  ping: {
+    params: Record<string, never>;
+    result: { pong: boolean };
+  };
+  startHub: {
+    params: {
+      tunnelPort: number;
+      targetHost?: string;
+    };
+    result: { started: boolean };
+  };
+  stopHub: {
+    params: Record<string, never>;
+    result: { stopped: boolean; wasRunning?: boolean };
+  };
+  updateAllowedEdges: {
+    params: {
+      edges: Array<{ id: string; secret: string }>;
+    };
+    result: { updated: boolean };
+  };
+  getHubStatus: {
+    params: Record<string, never>;
+    result: {
+      running: boolean;
+      tunnelPort: number;
+      connectedEdges: Array<{
+        edgeId: string;
+        connectedAt: number;
+        activeStreams: number;
+      }>;
+    };
+  };
+};
+
+export interface IHubConfig {
+  tunnelPort?: number;
+  targetHost?: string;
+}
+
+export class RemoteIngressHub extends EventEmitter {
+  private bridge: InstanceType<typeof plugins.smartrust.RustBridge<THubCommands>>;
+  private started = false;
+
+  constructor() {
+    super();
+
+    const packageDir = plugins.path.resolve(
+      plugins.path.dirname(new URL(import.meta.url).pathname),
+      '..',
+    );
+
+    this.bridge = new plugins.smartrust.RustBridge<THubCommands>({
+      binaryName: 'remoteingress-bin',
+      cliArgs: ['--management'],
+      requestTimeoutMs: 30_000,
+      readyTimeoutMs: 10_000,
+      localPaths: [
+        plugins.path.join(packageDir, 'dist_rust'),
+        plugins.path.join(packageDir, 'rust', 'target', 'release'),
+        plugins.path.join(packageDir, 'rust', 'target', 'debug'),
+      ],
+      searchSystemPath: false,
+    });
+
+    // Forward events from Rust binary
+    this.bridge.on('management:edgeConnected', (data: { edgeId: string }) => {
+      this.emit('edgeConnected', data);
+    });
+    this.bridge.on('management:edgeDisconnected', (data: { edgeId: string }) => {
+      this.emit('edgeDisconnected', data);
+    });
+    this.bridge.on('management:streamOpened', (data: { edgeId: string; streamId: number }) => {
+      this.emit('streamOpened', data);
+    });
+    this.bridge.on('management:streamClosed', (data: { edgeId: string; streamId: number }) => {
+      this.emit('streamClosed', data);
+    });
+  }
+
+  /**
+   * Start the hub — spawns the Rust binary and starts the tunnel server.
+   */
+  public async start(config: IHubConfig = {}): Promise<void> {
+    const spawned = await this.bridge.spawn();
+    if (!spawned) {
+      throw new Error('Failed to spawn remoteingress-bin');
+    }
+
+    await this.bridge.sendCommand('startHub', {
+      tunnelPort: config.tunnelPort ?? 8443,
+      targetHost: config.targetHost ?? '127.0.0.1',
+    });
+
+    this.started = true;
+  }
+
+  /**
+   * Stop the hub and kill the Rust process.
+   */
+  public async stop(): Promise<void> {
+    if (this.started) {
+      try {
+        await this.bridge.sendCommand('stopHub', {} as Record<string, never>);
+      } catch {
+        // Process may already be dead
+      }
+      this.bridge.kill();
+      this.started = false;
+    }
+  }
+
+  /**
+   * Update the list of allowed edges that can connect to this hub.
+   */
+  public async updateAllowedEdges(edges: Array<{ id: string; secret: string }>): Promise<void> {
+    await this.bridge.sendCommand('updateAllowedEdges', { edges });
+  }
+
+  /**
+   * Get the current hub status.
+   */
+  public async getStatus() {
+    return this.bridge.sendCommand('getHubStatus', {} as Record<string, never>);
+  }
+
+  /**
+   * Check if the bridge is running.
+   */
+  public get running(): boolean {
+    return this.bridge.running;
+  }
+}

package/ts/index.ts

@@ -1,14 +1,2 @@
-import * as plugins from './plugins.js';
-
-import { ConnectorPublic } from './connector.public.js';
-import { ConnectorPrivate } from './connector.private.js';
-
-export {
-  ConnectorPublic,
-  ConnectorPrivate
-}
-
-export const runCli = async () => {
-  const qenv = new plugins.qenv.Qenv();
-  const mode = await qenv.getEnvVarOnDemand('MODE');
-}
+export * from './classes.remoteingresshub.js';
+export * from './classes.remoteingressedge.js';

package/ts/plugins.ts

@@ -1,15 +1,7 @@
 // node native scope
-import * as tls from 'tls';
-import * as fs from 'fs';
-
-export {
-  tls,
-  fs,
-}
+import * as path from 'path';
+export { path };
 
 // @push.rocks scope
-import * as qenv from '@push.rocks/qenv';
-
-export {
-  qenv,
-}
+import * as smartrust from '@push.rocks/smartrust';
+export { smartrust };

package/dist_ts/connector.private.d.ts

@@ -1,6 +0,0 @@
-export declare class ConnectorPrivate {
-    private targetHost;
-    private targetPort;
-    constructor(targetHost: string, targetPort?: number);
-    private connectToPublicRemoteConnector;
-}

package/dist_ts/connector.private.js

@@ -1,31 +0,0 @@
-import * as plugins from './plugins.js';
-export class ConnectorPrivate {
-    constructor(targetHost, targetPort = 4000) {
-        this.targetHost = targetHost;
-        this.targetPort = targetPort;
-        this.connectToPublicRemoteConnector();
-    }
-    connectToPublicRemoteConnector() {
-        const options = {
-            // Include CA certificate if necessary, for example:
-            // ca: fs.readFileSync('path/to/ca.pem'),
-            rejectUnauthorized: true // Only set this to true if you are sure about the server's certificate
-        };
-        const tunnel = plugins.tls.connect(this.targetPort, options, () => {
-            console.log('Connected to PublicRemoteConnector on port 4000');
-        });
-        tunnel.on('data', (data) => {
-            const targetConnection = plugins.tls.connect({
-                host: this.targetHost,
-                port: this.targetPort,
-                // Include necessary options for the target connection
-            }, () => {
-                targetConnection.write(data);
-            });
-            targetConnection.on('data', (backData) => {
-                tunnel.write(backData); // Send data back through the tunnel
-            });
-        });
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdG9yLnByaXZhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jb25uZWN0b3IucHJpdmF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4QyxNQUFNLE9BQU8sZ0JBQWdCO0lBSTNCLFlBQVksVUFBa0IsRUFBRSxhQUFxQixJQUFJO1FBQ3ZELElBQUksQ0FBQyxVQUFVLEdBQUcsVUFBVSxDQUFDO1FBQzdCLElBQUksQ0FBQyxVQUFVLEdBQUcsVUFBVSxDQUFDO1FBQzdCLElBQUksQ0FBQyw4QkFBOEIsRUFBRSxDQUFDO0lBQ3hDLENBQUM7SUFFTyw4QkFBOEI7UUFDcEMsTUFBTSxPQUFPLEdBQUc7WUFDZCxvREFBb0Q7WUFDcEQseUNBQXlDO1lBQ3pDLGtCQUFrQixFQUFFLElBQUksQ0FBQyx1RUFBdUU7U0FDakcsQ0FBQztRQUVGLE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsT0FBTyxFQUFFLEdBQUcsRUFBRTtZQUNoRSxPQUFPLENBQUMsR0FBRyxDQUFDLGlEQUFpRCxDQUFDLENBQUM7UUFDakUsQ0FBQyxDQUFDLENBQUM7UUFFSCxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLElBQVksRUFBRSxFQUFFO1lBQ2pDLE1BQU0sZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUM7Z0JBQzNDLElBQUksRUFBRSxJQUFJLENBQUMsVUFBVTtnQkFDckIsSUFBSSxFQUFFLElBQUksQ0FBQyxVQUFVO2dCQUNyQixzREFBc0Q7YUFDdkQsRUFBRSxHQUFHLEVBQUU7Z0JBQ04sZ0JBQWdCLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQy9CLENBQUMsQ0FBQyxDQUFDO1lBRUgsZ0JBQWdCLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQWdCLEVBQUUsRUFBRTtnQkFDL0MsTUFBTSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLG9DQUFvQztZQUM5RCxDQUFDLENBQUMsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGIn0=

package/dist_ts/connector.public.d.ts

@@ -1,6 +0,0 @@
-export declare class ConnectorPublic {
-    private tunnel;
-    constructor();
-    private createTunnel;
-    private listenOnPorts;
-}

package/dist_ts/connector.public.js

@@ -1,40 +0,0 @@
-import * as plugins from './plugins.js';
-export class ConnectorPublic {
-    constructor() {
-        this.tunnel = null;
-        this.createTunnel();
-        this.listenOnPorts();
-    }
-    createTunnel() {
-        const options = {
-            key: plugins.fs.readFileSync('path/to/key.pem'),
-            cert: plugins.fs.readFileSync('path/to/cert.pem'),
-        };
-        const server = plugins.tls.createServer(options, (socket) => {
-            this.tunnel = socket;
-            console.log('Tunnel established with LocalConnector');
-        });
-        server.listen(4000, () => {
-            console.log('PublicRemoteConnector listening for tunnel on port 4000');
-        });
-    }
-    listenOnPorts() {
-        // Example for port 80, adapt for port 443 similarly
-        // Note: TLS for the initial connection might not apply directly for HTTP/HTTPS traffic without additional setup
-        const options = {
-            key: plugins.fs.readFileSync('path/to/key.pem'),
-            cert: plugins.fs.readFileSync('path/to/cert.pem'),
-        };
-        plugins.tls.createServer(options, (socket) => {
-            console.log('Received connection, tunneling to LocalConnector');
-            if (this.tunnel) {
-                socket.pipe(this.tunnel).pipe(socket);
-            }
-            else {
-                console.log('Tunnel to LocalConnector not established');
-                socket.end();
-            }
-        }).listen(80); // Repeat this block for any other ports you wish to listen on
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdG9yLnB1YmxpYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2Nvbm5lY3Rvci5wdWJsaWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFFeEMsTUFBTSxPQUFPLGVBQWU7SUFHMUI7UUFGUSxXQUFNLEdBQWlDLElBQUksQ0FBQztRQUdsRCxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7UUFDcEIsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO0lBQ3ZCLENBQUM7SUFFTyxZQUFZO1FBQ2xCLE1BQU0sT0FBTyxHQUFHO1lBQ2QsR0FBRyxFQUFFLE9BQU8sQ0FBQyxFQUFFLENBQUMsWUFBWSxDQUFDLGlCQUFpQixDQUFDO1lBQy9DLElBQUksRUFBRSxPQUFPLENBQUMsRUFBRSxDQUFDLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQztTQUNsRCxDQUFDO1FBRUYsTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsT0FBTyxFQUFFLENBQUMsTUFBNkIsRUFBRSxFQUFFO1lBQ2pGLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO1lBQ3JCLE9BQU8sQ0FBQyxHQUFHLENBQUMsd0NBQXdDLENBQUMsQ0FBQztRQUN4RCxDQUFDLENBQUMsQ0FBQztRQUVILE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLEdBQUcsRUFBRTtZQUN2QixPQUFPLENBQUMsR0FBRyxDQUFDLHlEQUF5RCxDQUFDLENBQUM7UUFDekUsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU8sYUFBYTtRQUNuQixvREFBb0Q7UUFDcEQsZ0hBQWdIO1FBQ2hILE1BQU0sT0FBTyxHQUFHO1lBQ2QsR0FBRyxFQUFFLE9BQU8sQ0FBQyxFQUFFLENBQUMsWUFBWSxDQUFDLGlCQUFpQixDQUFDO1lBQy9DLElBQUksRUFBRSxPQUFPLENBQUMsRUFBRSxDQUFDLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQztTQUNsRCxDQUFDO1FBRUYsT0FBTyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsT0FBTyxFQUFFLENBQUMsTUFBNkIsRUFBRSxFQUFFO1lBQ2xFLE9BQU8sQ0FBQyxHQUFHLENBQUMsa0RBQWtELENBQUMsQ0FBQztZQUNoRSxJQUFJLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztnQkFDaEIsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1lBQ3hDLENBQUM7aUJBQU0sQ0FBQztnQkFDTixPQUFPLENBQUMsR0FBRyxDQUFDLDBDQUEwQyxDQUFDLENBQUM7Z0JBQ3hELE1BQU0sQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNmLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyw4REFBOEQ7SUFDL0UsQ0FBQztDQUNGIn0=

package/ts/connector.private.ts

@@ -1,38 +0,0 @@
-import * as plugins from './plugins.js';
-
-export class ConnectorPrivate {
-  private targetHost: string;
-  private targetPort: number;
-
-  constructor(targetHost: string, targetPort: number = 4000) {
-    this.targetHost = targetHost;
-    this.targetPort = targetPort;
-    this.connectToPublicRemoteConnector();
-  }
-
-  private connectToPublicRemoteConnector(): void {
-    const options = {
-      // Include CA certificate if necessary, for example:
-      // ca: fs.readFileSync('path/to/ca.pem'),
-      rejectUnauthorized: true // Only set this to true if you are sure about the server's certificate
-    };
-
-    const tunnel = plugins.tls.connect(this.targetPort, options, () => {
-      console.log('Connected to PublicRemoteConnector on port 4000');
-    });
-
-    tunnel.on('data', (data: Buffer) => {
-      const targetConnection = plugins.tls.connect({
-        host: this.targetHost,
-        port: this.targetPort,
-        // Include necessary options for the target connection
-      }, () => {
-        targetConnection.write(data);
-      });
-
-      targetConnection.on('data', (backData: Buffer) => {
-        tunnel.write(backData); // Send data back through the tunnel
-      });
-    });
-  }
-}

package/ts/connector.public.ts

@@ -1,45 +0,0 @@
-import * as plugins from './plugins.js';
-
-export class ConnectorPublic {
-  private tunnel: plugins.tls.TLSSocket | null = null;
-
-  constructor() {
-    this.createTunnel();
-    this.listenOnPorts();
-  }
-
-  private createTunnel(): void {
-    const options = {
-      key: plugins.fs.readFileSync('path/to/key.pem'),
-      cert: plugins.fs.readFileSync('path/to/cert.pem'),
-    };
-
-    const server = plugins.tls.createServer(options, (socket: plugins.tls.TLSSocket) => {
-      this.tunnel = socket;
-      console.log('Tunnel established with LocalConnector');
-    });
-
-    server.listen(4000, () => {
-      console.log('PublicRemoteConnector listening for tunnel on port 4000');
-    });
-  }
-
-  private listenOnPorts(): void {
-    // Example for port 80, adapt for port 443 similarly
-    // Note: TLS for the initial connection might not apply directly for HTTP/HTTPS traffic without additional setup
-    const options = {
-      key: plugins.fs.readFileSync('path/to/key.pem'),
-      cert: plugins.fs.readFileSync('path/to/cert.pem'),
-    };
-
-    plugins.tls.createServer(options, (socket: plugins.tls.TLSSocket) => {
-      console.log('Received connection, tunneling to LocalConnector');
-      if (this.tunnel) {
-        socket.pipe(this.tunnel).pipe(socket);
-      } else {
-        console.log('Tunnel to LocalConnector not established');
-        socket.end();
-      }
-    }).listen(80); // Repeat this block for any other ports you wish to listen on
-  }
-}