@push.rocks/smartrust 1.1.0

package/dist_ts/classes.rustbridge.js

@@ -0,0 +1,231 @@
+import * as plugins from './plugins.js';
+import { RustBinaryLocator } from './classes.rustbinarylocator.js';
+const defaultLogger = {
+    log() { },
+};
+/**
+ * Generic bridge between TypeScript and a Rust binary.
+ * Communicates via JSON-over-stdin/stdout IPC protocol.
+ *
+ * @typeParam TCommands - Map of command names to their param/result types
+ */
+export class RustBridge extends plugins.events.EventEmitter {
+    locator;
+    options;
+    logger;
+    childProcess = null;
+    readlineInterface = null;
+    pendingRequests = new Map();
+    requestCounter = 0;
+    isRunning = false;
+    binaryPath = null;
+    constructor(options) {
+        super();
+        this.logger = options.logger || defaultLogger;
+        this.options = {
+            cliArgs: ['--management'],
+            requestTimeoutMs: 30000,
+            readyTimeoutMs: 10000,
+            readyEventName: 'ready',
+            ...options,
+        };
+        this.locator = new RustBinaryLocator(options, this.logger);
+    }
+    /**
+     * Spawn the Rust binary and wait for it to signal readiness.
+     * Returns true if the binary was found and spawned successfully.
+     */
+    async spawn() {
+        this.binaryPath = await this.locator.findBinary();
+        if (!this.binaryPath) {
+            return false;
+        }
+        return new Promise((resolve) => {
+            try {
+                const env = this.options.env
+                    ? { ...process.env, ...this.options.env }
+                    : { ...process.env };
+                this.childProcess = plugins.childProcess.spawn(this.binaryPath, this.options.cliArgs, {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    env,
+                });
+                // Handle stderr
+                this.childProcess.stderr?.on('data', (data) => {
+                    const lines = data.toString().split('\n').filter((l) => l.trim());
+                    for (const line of lines) {
+                        this.logger.log('debug', `[${this.options.binaryName}] ${line}`);
+                        this.emit('stderr', line);
+                    }
+                });
+                // Handle stdout via readline for line-delimited JSON
+                this.readlineInterface = plugins.readline.createInterface({ input: this.childProcess.stdout });
+                this.readlineInterface.on('line', (line) => {
+                    this.handleLine(line.trim());
+                });
+                // Handle process exit
+                this.childProcess.on('exit', (code, signal) => {
+                    this.logger.log('info', `Process exited (code=${code}, signal=${signal})`);
+                    this.cleanup();
+                    this.emit('exit', code, signal);
+                });
+                this.childProcess.on('error', (err) => {
+                    this.logger.log('error', `Process error: ${err.message}`);
+                    this.cleanup();
+                    resolve(false);
+                });
+                // Wait for the ready event
+                const readyTimeout = setTimeout(() => {
+                    this.logger.log('error', `Process did not send ready event within ${this.options.readyTimeoutMs}ms`);
+                    this.kill();
+                    resolve(false);
+                }, this.options.readyTimeoutMs);
+                this.once(`management:${this.options.readyEventName}`, () => {
+                    clearTimeout(readyTimeout);
+                    this.isRunning = true;
+                    this.logger.log('info', `Bridge connected to ${this.options.binaryName}`);
+                    this.emit('ready');
+                    resolve(true);
+                });
+            }
+            catch (err) {
+                this.logger.log('error', `Failed to spawn: ${err.message}`);
+                resolve(false);
+            }
+        });
+    }
+    /**
+     * Send a typed command to the Rust process and wait for the response.
+     */
+    async sendCommand(method, params) {
+        if (!this.childProcess || !this.isRunning) {
+            throw new Error(`${this.options.binaryName} bridge is not running`);
+        }
+        const id = `req_${++this.requestCounter}`;
+        const request = { id, method, params };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Command '${method}' timed out after ${this.options.requestTimeoutMs}ms`));
+            }, this.options.requestTimeoutMs);
+            this.pendingRequests.set(id, { resolve, reject, timer });
+            const json = JSON.stringify(request) + '\n';
+            this.childProcess.stdin.write(json, (err) => {
+                if (err) {
+                    clearTimeout(timer);
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`Failed to write to stdin: ${err.message}`));
+                }
+            });
+        });
+    }
+    /**
+     * Kill the Rust process and clean up all resources.
+     */
+    kill() {
+        if (this.childProcess) {
+            const proc = this.childProcess;
+            this.childProcess = null;
+            this.isRunning = false;
+            // Close readline
+            if (this.readlineInterface) {
+                this.readlineInterface.close();
+                this.readlineInterface = null;
+            }
+            // Reject pending requests
+            for (const [, pending] of this.pendingRequests) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error(`${this.options.binaryName} process killed`));
+            }
+            this.pendingRequests.clear();
+            // Remove all listeners
+            proc.removeAllListeners();
+            proc.stdout?.removeAllListeners();
+            proc.stderr?.removeAllListeners();
+            proc.stdin?.removeAllListeners();
+            // Kill the process
+            try {
+                proc.kill('SIGTERM');
+            }
+            catch { /* already dead */ }
+            // Destroy stdio pipes
+            try {
+                proc.stdin?.destroy();
+            }
+            catch { /* ignore */ }
+            try {
+                proc.stdout?.destroy();
+            }
+            catch { /* ignore */ }
+            try {
+                proc.stderr?.destroy();
+            }
+            catch { /* ignore */ }
+            // Unref so Node doesn't wait
+            try {
+                proc.unref();
+            }
+            catch { /* ignore */ }
+            // Force kill after 5 seconds
+            setTimeout(() => {
+                try {
+                    proc.kill('SIGKILL');
+                }
+                catch { /* already dead */ }
+            }, 5000).unref();
+        }
+    }
+    /**
+     * Whether the bridge is currently running.
+     */
+    get running() {
+        return this.isRunning;
+    }
+    handleLine(line) {
+        if (!line)
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            this.logger.log('warn', `Non-JSON output: ${line}`);
+            return;
+        }
+        // Check if it's an event (has 'event' field, no 'id')
+        if ('event' in parsed && !('id' in parsed)) {
+            const event = parsed;
+            this.emit(`management:${event.event}`, event.data);
+            return;
+        }
+        // Otherwise it's a response (has 'id' field)
+        if ('id' in parsed) {
+            const response = parsed;
+            const pending = this.pendingRequests.get(response.id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(response.id);
+                if (response.success) {
+                    pending.resolve(response.result);
+                }
+                else {
+                    pending.reject(new Error(response.error || 'Unknown error from Rust process'));
+                }
+            }
+        }
+    }
+    cleanup() {
+        this.isRunning = false;
+        this.childProcess = null;
+        if (this.readlineInterface) {
+            this.readlineInterface.close();
+            this.readlineInterface = null;
+        }
+        // Reject all pending requests
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`${this.options.binaryName} process exited`));
+        }
+        this.pendingRequests.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.rustbridge.js","sourceRoot":"","sources":["../ts/classes.rustbridge.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -0,0 +1,3 @@
+export { RustBridge } from './classes.rustbridge.js';
+export { RustBinaryLocator } from './classes.rustbinarylocator.js';
+export * from './interfaces/index.js';

package/dist_ts/index.js

@@ -0,0 +1,4 @@
+export { RustBridge } from './classes.rustbridge.js';
+export { RustBinaryLocator } from './classes.rustbinarylocator.js';
+export * from './interfaces/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDckQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDbkUsY0FBYyx1QkFBdUIsQ0FBQyJ9

package/dist_ts/interfaces/config.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Minimal logger interface for the bridge.
+ */
+export interface IRustBridgeLogger {
+    log(level: string, message: string, data?: Record<string, any>): void;
+}
+/**
+ * Options for locating a Rust binary.
+ */
+export interface IBinaryLocatorOptions {
+    /** Name of the binary (e.g., 'rustproxy') */
+    binaryName: string;
+    /** Environment variable to check for explicit binary path (e.g., 'SMARTPROXY_RUST_BINARY') */
+    envVarName?: string;
+    /** Prefix for platform-specific npm packages (e.g., '@push.rocks/smartproxy') */
+    platformPackagePrefix?: string;
+    /** Additional local paths to search (defaults to ./rust/target/release/<binaryName> and ./rust/target/debug/<binaryName>) */
+    localPaths?: string[];
+    /** Whether to search the system PATH (default: true) */
+    searchSystemPath?: boolean;
+    /** Explicit binary path override - skips all other search */
+    binaryPath?: string;
+}
+/**
+ * Options for the RustBridge.
+ */
+export interface IRustBridgeOptions extends IBinaryLocatorOptions {
+    /** CLI arguments passed to the binary (default: ['--management']) */
+    cliArgs?: string[];
+    /** Timeout for individual requests in ms (default: 30000) */
+    requestTimeoutMs?: number;
+    /** Timeout for the ready event during spawn in ms (default: 10000) */
+    readyTimeoutMs?: number;
+    /** Additional environment variables for the child process */
+    env?: Record<string, string>;
+    /** Name of the ready event emitted by the Rust binary (default: 'ready') */
+    readyEventName?: string;
+    /** Optional logger instance */
+    logger?: IRustBridgeLogger;
+}

package/dist_ts/interfaces/config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvaW50ZXJmYWNlcy9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ipc.js';
+export * from './config.js';

package/dist_ts/interfaces/index.js

@@ -0,0 +1,3 @@
+export * from './ipc.js';
+export * from './config.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDIn0=

package/dist_ts/interfaces/ipc.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Management request sent to the Rust binary via stdin.
+ */
+export interface IManagementRequest {
+    id: string;
+    method: string;
+    params: Record<string, any>;
+}
+/**
+ * Management response received from the Rust binary via stdout.
+ */
+export interface IManagementResponse {
+    id: string;
+    success: boolean;
+    result?: any;
+    error?: string;
+}
+/**
+ * Management event received from the Rust binary (unsolicited, no id field).
+ */
+export interface IManagementEvent {
+    event: string;
+    data: any;
+}
+/**
+ * Definition of a single command supported by a Rust binary.
+ */
+export interface ICommandDefinition<TParams = any, TResult = any> {
+    params: TParams;
+    result: TResult;
+}
+/**
+ * Map of command names to their definitions.
+ * Used to type-safe the bridge's sendCommand method.
+ */
+export type TCommandMap = Record<string, ICommandDefinition>;

package/dist_ts/interfaces/ipc.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXBjLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvaW50ZXJmYWNlcy9pcGMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/paths.d.ts

@@ -0,0 +1 @@
+export declare const packageDir: string;

package/dist_ts/paths.js

@@ -0,0 +1,3 @@
+import * as plugins from './plugins.js';
+export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '../');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQ3pDLE9BQU8sQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLHdCQUF3QixDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQy9ELEtBQUssQ0FDTixDQUFDIn0=

package/dist_ts/plugins.d.ts

@@ -0,0 +1,8 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import * as childProcess from 'child_process';
+import * as readline from 'readline';
+import * as events from 'events';
+export { path, fs, childProcess, readline, events };
+import * as smartpath from '@push.rocks/smartpath';
+export { smartpath };

package/dist_ts/plugins.js

@@ -0,0 +1,11 @@
+// native scope
+import * as path from 'path';
+import * as fs from 'fs';
+import * as childProcess from 'child_process';
+import * as readline from 'readline';
+import * as events from 'events';
+export { path, fs, childProcess, readline, events };
+// @push.rocks scope
+import * as smartpath from '@push.rocks/smartpath';
+export { smartpath };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZTtBQUNmLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxZQUFZLE1BQU0sZUFBZSxDQUFDO0FBQzlDLE9BQU8sS0FBSyxRQUFRLE1BQU0sVUFBVSxDQUFDO0FBQ3JDLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBRWpDLE9BQU8sRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLENBQUM7QUFFcEQsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUFFLFNBQVMsRUFBRSxDQUFDIn0=

package/npmextra.json

@@ -0,0 +1,24 @@
+{
+  "@git.zone/cli": {
+    "projectType": "npm",
+    "module": {
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
+      "gitrepo": "smartrust",
+      "description": "a bridge between JS engines and rust",
+      "npmPackagename": "@push.rocks/smartrust",
+      "license": "MIT",
+      "projectDomain": "push.rocks"
+    },
+    "release": {
+      "accessLevel": "public",
+      "registries": [
+        "https://verdaccio.lossless.digital",
+        "https://registry.npmjs.org"
+      ]
+    }
+  },
+  "@ship.zone/szci": {
+    "npmGlobalTools": []
+  }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@push.rocks/smartrust",
+  "version": "1.1.0",
+  "private": false,
+  "description": "a bridge between JS engines and rust",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
+  "author": "Task Venture Capital GmbH",
+  "license": "MIT",
+  "scripts": {
+    "test": "(tstest test/ --verbose --logfile --timeout 60)",
+    "build": "(tsbuild tsfolders --allowimplicitany)",
+    "buildDocs": "(tsdoc)"
+  },
+  "devDependencies": {
+    "@git.zone/tsbuild": "^4.1.2",
+    "@git.zone/tsrun": "^2.0.1",
+    "@git.zone/tstest": "^3.1.8",
+    "@types/node": "^25.2.0"
+  },
+  "dependencies": {
+    "@push.rocks/smartpath": "^6.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# @push.rocks/smartrust
+a bridge between JS engines and rust
+
+## How to create the docs
+To create docs run gitzone aidoc.

package/test/helpers/mock-rust-binary.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+/**
+ * Mock "Rust binary" for testing the RustBridge IPC protocol.
+ * Reads JSON lines from stdin, writes JSON lines to stdout.
+ * Emits a ready event on startup.
+ */
+
+import { createInterface } from 'readline';
+
+// Emit ready event
+const readyEvent = JSON.stringify({ event: 'ready', data: { version: '1.0.0' } });
+process.stdout.write(readyEvent + '\n');
+
+const rl = createInterface({ input: process.stdin });
+
+rl.on('line', (line) => {
+  let request;
+  try {
+    request = JSON.parse(line.trim());
+  } catch {
+    return;
+  }
+
+  const { id, method, params } = request;
+
+  if (method === 'echo') {
+    // Echo back the params as result
+    const response = JSON.stringify({ id, success: true, result: params });
+    process.stdout.write(response + '\n');
+  } else if (method === 'error') {
+    // Return an error
+    const response = JSON.stringify({ id, success: false, error: 'Test error message' });
+    process.stdout.write(response + '\n');
+  } else if (method === 'emitEvent') {
+    // Emit a custom event, then respond with success
+    const event = JSON.stringify({ event: params.eventName, data: params.eventData });
+    process.stdout.write(event + '\n');
+    const response = JSON.stringify({ id, success: true, result: null });
+    process.stdout.write(response + '\n');
+  } else if (method === 'slow') {
+    // Respond after a delay
+    setTimeout(() => {
+      const response = JSON.stringify({ id, success: true, result: { delayed: true } });
+      process.stdout.write(response + '\n');
+    }, 100);
+  } else if (method === 'exit') {
+    // Graceful exit
+    const response = JSON.stringify({ id, success: true, result: null });
+    process.stdout.write(response + '\n');
+    process.exit(0);
+  } else {
+    // Unknown command
+    const response = JSON.stringify({ id, success: false, error: `Unknown method: ${method}` });
+    process.stdout.write(response + '\n');
+  }
+});
+
+// Handle SIGTERM gracefully
+process.on('SIGTERM', () => {
+  process.exit(0);
+});

package/test/test.rustbinarylocator.node.ts

@@ -0,0 +1,98 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as path from 'path';
+import * as fs from 'fs';
+import { RustBinaryLocator } from '../ts/classes.rustbinarylocator.js';
+
+const testDir = path.resolve(path.dirname(new URL(import.meta.url).pathname));
+
+tap.test('should return null when no binary is found', async () => {
+  const locator = new RustBinaryLocator({
+    binaryName: 'nonexistent-binary-xyz',
+    searchSystemPath: false,
+  });
+  const result = await locator.findBinary();
+  expect(result).toBeNull();
+});
+
+tap.test('should use explicit binaryPath when provided', async () => {
+  const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
+  const locator = new RustBinaryLocator({
+    binaryName: 'mock-rust-binary',
+    binaryPath: mockBinaryPath,
+    searchSystemPath: false,
+  });
+  const result = await locator.findBinary();
+  expect(result).toEqual(mockBinaryPath);
+});
+
+tap.test('should cache the result', async () => {
+  const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
+  const locator = new RustBinaryLocator({
+    binaryName: 'mock-rust-binary',
+    binaryPath: mockBinaryPath,
+    searchSystemPath: false,
+  });
+
+  const first = await locator.findBinary();
+  const second = await locator.findBinary();
+  expect(first).toEqual(second);
+  expect(first).toEqual(mockBinaryPath);
+});
+
+tap.test('should clear cache', async () => {
+  const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
+  const locator = new RustBinaryLocator({
+    binaryName: 'mock-rust-binary',
+    binaryPath: mockBinaryPath,
+    searchSystemPath: false,
+  });
+
+  const first = await locator.findBinary();
+  expect(first).toEqual(mockBinaryPath);
+
+  locator.clearCache();
+  // After clearing, next call should re-search and still find it
+  const second = await locator.findBinary();
+  expect(second).toEqual(mockBinaryPath);
+});
+
+tap.test('should fall back to env var when binaryPath not set', async () => {
+  const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
+  const envVar = 'TEST_SMARTRUST_BINARY_' + Date.now();
+  process.env[envVar] = mockBinaryPath;
+
+  const locator = new RustBinaryLocator({
+    binaryName: 'mock-rust-binary',
+    envVarName: envVar,
+    searchSystemPath: false,
+  });
+
+  const result = await locator.findBinary();
+  expect(result).toEqual(mockBinaryPath);
+
+  delete process.env[envVar];
+});
+
+tap.test('should find binary in local paths', async () => {
+  const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
+  const locator = new RustBinaryLocator({
+    binaryName: 'mock-rust-binary',
+    localPaths: ['/nonexistent/path/binary', mockBinaryPath],
+    searchSystemPath: false,
+  });
+
+  const result = await locator.findBinary();
+  expect(result).toEqual(mockBinaryPath);
+});
+
+tap.test('should find node in system PATH', async () => {
+  const locator = new RustBinaryLocator({
+    binaryName: 'node',
+    searchSystemPath: true,
+  });
+
+  const result = await locator.findBinary();
+  expect(result).not.toBeNull();
+});
+
+export default tap.start();