push.rocks/smartrust
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(transport): introduce transport abstraction and socket-mode support for RustBridge

Browse Source
This commit is contained in:
Jürgen Kunz
2026-02-26 08:44:28 +00:00
parent 0c39e157c2
commit deda8cc4ee
14 changed files with 1064 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ts/00_commitinfo_data.ts
View File

@@ -3,6 +3,6 @@
*/
export const commitinfo = {
name: '@push.rocks/smartrust',
version: '1.2.1',
version: '1.3.0',
description: 'a bridge between JS engines and rust'
}

51
ts/classes.linescanner.ts Normal file
View File

@@ -0,0 +1,51 @@
import type { IRustBridgeLogger } from './interfaces/index.js';
/**
* Buffer-based newline scanner for streaming binary data.
* Accumulates chunks and emits complete lines via callback.
* Used by both StdioTransport and SocketTransport.
*/
export class LineScanner {
private buffer: Buffer = Buffer.alloc(0);
private maxPayloadSize: number;
private logger: IRustBridgeLogger;
constructor(maxPayloadSize: number, logger: IRustBridgeLogger) {
this.maxPayloadSize = maxPayloadSize;
this.logger = logger;
}
/**
* Feed a chunk of data. Calls onLine for each complete newline-terminated line found.
*/
public push(chunk: Buffer, onLine: (line: string) => void): void {
this.buffer = Buffer.concat([this.buffer, chunk]);
let newlineIndex: number;
while ((newlineIndex = this.buffer.indexOf(0x0A)) !== -1) {
const lineBuffer = this.buffer.subarray(0, newlineIndex);
this.buffer = this.buffer.subarray(newlineIndex + 1);
if (lineBuffer.length > this.maxPayloadSize) {
this.logger.log('error', `Inbound message exceeds maxPayloadSize (${lineBuffer.length} bytes), dropping`);
continue;
}
const line = lineBuffer.toString('utf8').trim();
if (line) {
onLine(line);
}
}
// Prevent OOM if sender never sends newline
if (this.buffer.length > this.maxPayloadSize) {
this.logger.log('error', `Buffer exceeded maxPayloadSize (${this.buffer.length} bytes) without newline, clearing`);
this.buffer = Buffer.alloc(0);
}
}
/** Reset the internal buffer. */
public clear(): void {
this.buffer = Buffer.alloc(0);
}
}

242
ts/classes.rustbridge.ts
View File

@@ -1,15 +1,19 @@
import * as plugins from './plugins.js';
import { RustBinaryLocator } from './classes.rustbinarylocator.js';
import { StreamingResponse } from './classes.streamingresponse.js';
import { StdioTransport } from './classes.stdiotransport.js';
import { SocketTransport } from './classes.sockettransport.js';
import type {
IRustBridgeOptions,
IRustBridgeLogger,
ISocketConnectOptions,
TCommandMap,
IManagementRequest,
IManagementResponse,
IManagementEvent,
TStreamingCommandKeys,
TExtractChunk,
IRustTransport,
} from './interfaces/index.js';
const defaultLogger: IRustBridgeLogger = {
@@ -18,7 +22,8 @@ const defaultLogger: IRustBridgeLogger = {
/**
* Generic bridge between TypeScript and a Rust binary.
* Communicates via JSON-over-stdin/stdout IPC protocol.
* Communicates via JSON-over-stdin/stdout IPC protocol (stdio mode)
* or JSON-over-Unix-socket/named-pipe (socket mode).
*
* @typeParam TCommands - Map of command names to their param/result types
*/
@@ -26,9 +31,7 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
private locator: RustBinaryLocator;
private options: Required<Pick<IRustBridgeOptions, 'cliArgs' | 'requestTimeoutMs' | 'readyTimeoutMs' | 'readyEventName' | 'maxPayloadSize'>> & IRustBridgeOptions;
private logger: IRustBridgeLogger;
private childProcess: plugins.childProcess.ChildProcess | null = null;
private stdoutBuffer: Buffer = Buffer.alloc(0);
private stderrRemainder: string = '';
private transport: IRustTransport | null = null;
private pendingRequests = new Map<string, {
resolve: (value: any) => void;
reject: (error: Error) => void;
@@ -63,71 +66,93 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
return false;
}
const transport = new StdioTransport({
binaryPath: this.binaryPath,
cliArgs: this.options.cliArgs,
env: this.options.env,
maxPayloadSize: this.options.maxPayloadSize,
logger: this.logger,
});
return this.connectWithTransport(transport);
}
/**
* Connect to an already-running Rust daemon via Unix socket or named pipe.
* Returns true if the connection was established and the daemon signaled readiness.
*
* @param socketPath - Path to Unix socket or Windows named pipe
* @param socketOptions - Optional socket connection options (reconnect, etc.)
*/
public async connect(socketPath: string, socketOptions?: ISocketConnectOptions): Promise<boolean> {
const transport = new SocketTransport({
socketPath,
maxPayloadSize: this.options.maxPayloadSize,
logger: this.logger,
autoReconnect: socketOptions?.autoReconnect,
reconnectBaseDelayMs: socketOptions?.reconnectBaseDelayMs,
reconnectMaxDelayMs: socketOptions?.reconnectMaxDelayMs,
maxReconnectAttempts: socketOptions?.maxReconnectAttempts,
});
return this.connectWithTransport(transport);
}
/**
* Internal: wire up any transport and wait for the ready handshake.
*/
private connectWithTransport(transport: IRustTransport): Promise<boolean> {
return new Promise<boolean>((resolve) => {
try {
const env = this.options.env
? { ...process.env, ...this.options.env }
: { ...process.env };
this.transport = transport;
this.childProcess = plugins.childProcess.spawn(this.binaryPath!, this.options.cliArgs, {
stdio: ['pipe', 'pipe', 'pipe'],
env,
// Wire transport events
transport.on('line', (line: string) => this.handleLine(line));
transport.on('stderr', (line: string) => {
this.logger.log('debug', `[${this.options.binaryName}] ${line}`);
this.emit('stderr', line);
});
// Handle stderr with cross-chunk buffering
this.childProcess.stderr?.on('data', (data: Buffer) => {
this.stderrRemainder += data.toString();
const lines = this.stderrRemainder.split('\n');
// Keep the last element (incomplete line) as remainder
this.stderrRemainder = lines.pop()!;
for (const line of lines) {
const trimmed = line.trim();
if (trimmed) {
this.logger.log('debug', `[${this.options.binaryName}] ${trimmed}`);
this.emit('stderr', trimmed);
}
}
});
// Handle stdout via Buffer-based newline scanner
this.childProcess.stdout!.on('data', (chunk: Buffer) => {
this.handleStdoutChunk(chunk);
});
// Handle process exit
this.childProcess.on('exit', (code, signal) => {
this.logger.log('info', `Process exited (code=${code}, signal=${signal})`);
// Flush any remaining stderr
if (this.stderrRemainder.trim()) {
this.logger.log('debug', `[${this.options.binaryName}] ${this.stderrRemainder.trim()}`);
this.emit('stderr', this.stderrRemainder.trim());
}
transport.on('close', (...args: any[]) => {
this.logger.log('info', `Transport closed`);
this.cleanup();
this.emit('exit', code, signal);
this.emit('exit', ...args);
});
this.childProcess.on('error', (err) => {
this.logger.log('error', `Process error: ${err.message}`);
transport.on('error', (err: Error) => {
this.logger.log('error', `Transport 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);
transport.on('reconnected', () => {
this.logger.log('info', 'Transport reconnected, waiting for ready event');
this.emit('reconnected');
});
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);
// Connect the transport
transport.connect().then(() => {
// Wait for the ready event from the protocol layer
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: Error) => {
this.logger.log('error', `Transport connect failed: ${err.message}`);
resolve(false);
});
} catch (err: any) {
this.logger.log('error', `Failed to spawn: ${err.message}`);
this.logger.log('error', `Failed to connect: ${err.message}`);
resolve(false);
}
});
@@ -140,7 +165,7 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
method: K,
params: TCommands[K]['params'],
): Promise<TCommands[K]['result']> {
if (!this.childProcess || !this.isRunning) {
if (!this.transport?.connected || !this.isRunning) {
throw new Error(`${this.options.binaryName} bridge is not running`);
}
@@ -164,10 +189,10 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
this.pendingRequests.set(id, { resolve, reject, timer });
this.writeToStdin(json + '\n').catch((err) => {
this.transport!.write(json + '\n').catch((err) => {
clearTimeout(timer);
this.pendingRequests.delete(id);
reject(new Error(`Failed to write to stdin: ${err.message}`));
reject(new Error(`Failed to write to transport: ${err.message}`));
});
});
}
@@ -183,7 +208,7 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
): StreamingResponse<TExtractChunk<TCommands[K]>, TCommands[K]['result']> {
const streaming = new StreamingResponse<TExtractChunk<TCommands[K]>, TCommands[K]['result']>();
if (!this.childProcess || !this.isRunning) {
if (!this.transport?.connected || !this.isRunning) {
streaming.fail(new Error(`${this.options.binaryName} bridge is not running`));
return streaming;
}
@@ -213,28 +238,26 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
streaming,
});
this.writeToStdin(json + '\n').catch((err) => {
this.transport!.write(json + '\n').catch((err) => {
clearTimeout(timer);
this.pendingRequests.delete(id);
streaming.fail(new Error(`Failed to write to stdin: ${err.message}`));
streaming.fail(new Error(`Failed to write to transport: ${err.message}`));
});
return streaming;
}
/**
* Kill the Rust process and clean up all resources.
* Kill the connection and clean up all resources.
* For stdio: kills the child process (SIGTERM, then SIGKILL).
* For socket: closes the socket connection (does NOT kill the daemon).
*/
public kill(): void {
if (this.childProcess) {
const proc = this.childProcess;
this.childProcess = null;
if (this.transport) {
const transport = this.transport;
this.transport = null;
this.isRunning = false;
// Clear buffers
this.stdoutBuffer = Buffer.alloc(0);
this.stderrRemainder = '';
// Reject pending requests
for (const [, pending] of this.pendingRequests) {
clearTimeout(pending.timer);
@@ -242,27 +265,8 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
}
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();
transport.removeAllListeners();
transport.disconnect();
}
}
@@ -273,62 +277,6 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
return this.isRunning;
}
/**
* Buffer-based newline scanner for stdout chunks.
* Replaces readline to handle large payloads without buffering entire lines in a separate abstraction.
*/
private handleStdoutChunk(chunk: Buffer): void {
this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk]);
let newlineIndex: number;
while ((newlineIndex = this.stdoutBuffer.indexOf(0x0A)) !== -1) {
const lineBuffer = this.stdoutBuffer.subarray(0, newlineIndex);
this.stdoutBuffer = this.stdoutBuffer.subarray(newlineIndex + 1);
if (lineBuffer.length > this.options.maxPayloadSize) {
this.logger.log('error', `Inbound message exceeds maxPayloadSize (${lineBuffer.length} bytes), dropping`);
continue;
}
const line = lineBuffer.toString('utf8').trim();
this.handleLine(line);
}
// If accumulated buffer exceeds maxPayloadSize (sender never sends newline), clear to prevent OOM
if (this.stdoutBuffer.length > this.options.maxPayloadSize) {
this.logger.log('error', `Stdout buffer exceeded maxPayloadSize (${this.stdoutBuffer.length} bytes) without newline, clearing`);
this.stdoutBuffer = Buffer.alloc(0);
}
}
/**
* Write data to stdin with backpressure support.
* Waits for drain if the internal buffer is full.
*/
private writeToStdin(data: string): Promise<void> {
return new Promise<void>((resolve, reject) => {
if (!this.childProcess?.stdin) {
reject(new Error('stdin not available'));
return;
}
const canContinue = this.childProcess.stdin.write(data, 'utf8', (err) => {
if (err) {
reject(err);
}
});
if (canContinue) {
resolve();
} else {
// Wait for drain before resolving
this.childProcess.stdin.once('drain', () => {
resolve();
});
}
});
}
private handleLine(line: string): void {
if (!line) return;
@@ -381,9 +329,7 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
private cleanup(): void {
this.isRunning = false;
this.childProcess = null;
this.stdoutBuffer = Buffer.alloc(0);
this.stderrRemainder = '';
this.transport = null;
// Reject all pending requests
for (const [, pending] of this.pendingRequests) {

187
ts/classes.sockettransport.ts Normal file
View File

@@ -0,0 +1,187 @@
import * as plugins from './plugins.js';
import { LineScanner } from './classes.linescanner.js';
import type { IRustBridgeLogger } from './interfaces/index.js';
import type { IRustTransport } from './interfaces/transport.js';
export interface ISocketTransportOptions {
/** Path to Unix socket (Linux/macOS) or named pipe path (Windows) */
socketPath: string;
/** Maximum inbound message size in bytes */
maxPayloadSize: number;
/** Logger instance */
logger: IRustBridgeLogger;
/** Enable auto-reconnect on unexpected disconnect (default: false) */
autoReconnect?: boolean;
/** Initial delay between reconnect attempts in ms (default: 100) */
reconnectBaseDelayMs?: number;
/** Maximum delay between reconnect attempts in ms (default: 30000) */
reconnectMaxDelayMs?: number;
/** Maximum number of reconnect attempts before giving up (default: 10) */
maxReconnectAttempts?: number;
}
interface IResolvedSocketTransportOptions {
socketPath: string;
maxPayloadSize: number;
logger: IRustBridgeLogger;
autoReconnect: boolean;
reconnectBaseDelayMs: number;
reconnectMaxDelayMs: number;
maxReconnectAttempts: number;
}
/**
* Transport that connects to an already-running process via Unix socket or Windows named pipe.
* The JSON-over-newline protocol is identical to stdio; only the transport changes.
*/
export class SocketTransport extends plugins.events.EventEmitter implements IRustTransport {
private options: IResolvedSocketTransportOptions;
private socket: plugins.net.Socket | null = null;
private lineScanner: LineScanner;
private _connected: boolean = false;
private intentionalDisconnect: boolean = false;
private reconnectAttempts: number = 0;
private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
constructor(options: ISocketTransportOptions) {
super();
this.options = {
autoReconnect: false,
reconnectBaseDelayMs: 100,
reconnectMaxDelayMs: 30000,
maxReconnectAttempts: 10,
...options,
};
this.lineScanner = new LineScanner(options.maxPayloadSize, options.logger);
}
public get connected(): boolean {
return this._connected;
}
/**
* Connect to the socket. Resolves when the TCP/Unix connection is established.
*/
public async connect(): Promise<void> {
this.intentionalDisconnect = false;
this.reconnectAttempts = 0;
return this.doConnect();
}
private doConnect(): Promise<void> {
return new Promise<void>((resolve, reject) => {
let settled = false;
this.socket = plugins.net.connect({ path: this.options.socketPath });
this.socket.on('connect', () => {
if (!settled) {
settled = true;
this._connected = true;
this.reconnectAttempts = 0;
resolve();
}
});
this.socket.on('data', (chunk: Buffer) => {
this.lineScanner.push(chunk, (line) => {
this.emit('line', line);
});
});
this.socket.on('close', () => {
const wasConnected = this._connected;
this._connected = false;
this.lineScanner.clear();
if (!this.intentionalDisconnect && wasConnected && this.options.autoReconnect) {
this.attemptReconnect();
}
this.emit('close');
});
this.socket.on('error', (err: Error) => {
this._connected = false;
if (!settled) {
settled = true;
reject(err);
} else if (!this.intentionalDisconnect) {
this.emit('error', err);
}
});
});
}
private attemptReconnect(): void {
if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
this.options.logger.log('error', `Max reconnect attempts (${this.options.maxReconnectAttempts}) reached`);
this.emit('reconnect_failed');
return;
}
const delay = Math.min(
this.options.reconnectBaseDelayMs * Math.pow(2, this.reconnectAttempts),
this.options.reconnectMaxDelayMs,
);
this.reconnectAttempts++;
this.options.logger.log('info', `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.options.maxReconnectAttempts})`);
this.reconnectTimer = setTimeout(async () => {
this.reconnectTimer = null;
try {
await this.doConnect();
this.emit('reconnected');
} catch {
// doConnect rejected — the 'close' handler on the new socket will trigger another attempt
}
}, delay);
}
/**
* Write data to the socket with backpressure support.
*/
public async write(data: string): Promise<void> {
return new Promise<void>((resolve, reject) => {
if (!this.socket || !this._connected) {
reject(new Error('Socket not connected'));
return;
}
const canContinue = this.socket.write(data, 'utf8', (err) => {
if (err) {
reject(err);
}
});
if (canContinue) {
resolve();
} else {
this.socket.once('drain', () => {
resolve();
});
}
});
}
/**
* Close the socket connection. Does NOT kill the remote daemon.
*/
public disconnect(): void {
this.intentionalDisconnect = true;
if (this.reconnectTimer) {
clearTimeout(this.reconnectTimer);
this.reconnectTimer = null;
}
if (this.socket) {
const sock = this.socket;
this.socket = null;
this._connected = false;
this.lineScanner.clear();
sock.removeAllListeners();
sock.destroy();
}
}
}

149
ts/classes.stdiotransport.ts Normal file
View File

@@ -0,0 +1,149 @@
import * as plugins from './plugins.js';
import { LineScanner } from './classes.linescanner.js';
import type { IRustBridgeLogger } from './interfaces/index.js';
import type { IRustTransport } from './interfaces/transport.js';
export interface IStdioTransportOptions {
binaryPath: string;
cliArgs: string[];
env?: Record<string, string>;
maxPayloadSize: number;
logger: IRustBridgeLogger;
}
/**
* Transport that spawns a child process and communicates via stdin/stdout.
* Extracted from the original RustBridge process management logic.
*/
export class StdioTransport extends plugins.events.EventEmitter implements IRustTransport {
private options: IStdioTransportOptions;
private childProcess: plugins.childProcess.ChildProcess | null = null;
private lineScanner: LineScanner;
private stderrRemainder: string = '';
private _connected: boolean = false;
constructor(options: IStdioTransportOptions) {
super();
this.options = options;
this.lineScanner = new LineScanner(options.maxPayloadSize, options.logger);
}
public get connected(): boolean {
return this._connected;
}
/**
* Spawn the child process. Resolves when the process is running (not necessarily ready).
*/
public async connect(): Promise<void> {
const env = this.options.env
? { ...process.env, ...this.options.env }
: { ...process.env };
this.childProcess = plugins.childProcess.spawn(
this.options.binaryPath,
this.options.cliArgs,
{ stdio: ['pipe', 'pipe', 'pipe'], env },
);
// Handle stderr with cross-chunk buffering
this.childProcess.stderr?.on('data', (data: Buffer) => {
this.stderrRemainder += data.toString();
const lines = this.stderrRemainder.split('\n');
this.stderrRemainder = lines.pop()!;
for (const line of lines) {
const trimmed = line.trim();
if (trimmed) {
this.emit('stderr', trimmed);
}
}
});
// Handle stdout via LineScanner
this.childProcess.stdout!.on('data', (chunk: Buffer) => {
this.lineScanner.push(chunk, (line) => {
this.emit('line', line);
});
});
// Handle process exit
this.childProcess.on('exit', (code: number | null, signal: string | null) => {
// Flush remaining stderr
if (this.stderrRemainder.trim()) {
this.emit('stderr', this.stderrRemainder.trim());
}
this._connected = false;
this.lineScanner.clear();
this.stderrRemainder = '';
this.emit('close', code, signal);
});
this.childProcess.on('error', (err: Error) => {
this._connected = false;
this.emit('error', err);
});
this._connected = true;
}
/**
* Write data to stdin with backpressure support.
*/
public async write(data: string): Promise<void> {
return new Promise<void>((resolve, reject) => {
if (!this.childProcess?.stdin) {
reject(new Error('stdin not available'));
return;
}
const canContinue = this.childProcess.stdin.write(data, 'utf8', (err) => {
if (err) {
reject(err);
}
});
if (canContinue) {
resolve();
} else {
this.childProcess.stdin.once('drain', () => {
resolve();
});
}
});
}
/**
* Kill the child process. Sends SIGTERM, then SIGKILL after 5s.
*/
public disconnect(): void {
if (!this.childProcess) return;
const proc = this.childProcess;
this.childProcess = null;
this._connected = false;
this.lineScanner.clear();
this.stderrRemainder = '';
// 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();
}
}

3
ts/index.ts
View File

@@ -1,4 +1,7 @@
export { RustBridge } from './classes.rustbridge.js';
export { RustBinaryLocator } from './classes.rustbinarylocator.js';
export { StreamingResponse } from './classes.streamingresponse.js';
export { StdioTransport } from './classes.stdiotransport.js';
export { SocketTransport } from './classes.sockettransport.js';
export { LineScanner } from './classes.linescanner.js';
export * from './interfaces/index.js';

14
ts/interfaces/config.ts
View File

@@ -45,3 +45,17 @@ export interface IRustBridgeOptions extends IBinaryLocatorOptions {
* Resets on each chunk received. */
streamTimeoutMs?: number;
}
/**
* Options for connecting to an already-running daemon via Unix socket or named pipe.
*/
export interface ISocketConnectOptions {
/** Enable auto-reconnect on unexpected disconnect (default: false) */
autoReconnect?: boolean;
/** Initial delay between reconnect attempts in ms (default: 100) */
reconnectBaseDelayMs?: number;
/** Maximum delay between reconnect attempts in ms (default: 30000) */
reconnectMaxDelayMs?: number;
/** Maximum number of reconnect attempts before giving up (default: 10) */
maxReconnectAttempts?: number;
}

1
ts/interfaces/index.ts
View File

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

26
ts/interfaces/transport.ts Normal file
View File

@@ -0,0 +1,26 @@
import type * as plugins from '../plugins.js';
/**
* Abstract transport for communicating with a Rust process.
* Both stdio and socket transports implement this interface.
*
* Events emitted:
* - 'line' (line: string) — a complete newline-terminated JSON line received
* - 'error' (err: Error) — transport-level error
* - 'close' (...args: any[]) — transport has closed/disconnected
* - 'stderr' (line: string) — stderr output (stdio transport only)
* - 'reconnected' () — transport reconnected after unexpected disconnect (socket only)
*/
export interface IRustTransport extends plugins.events.EventEmitter {
/** Connect the transport (spawn process or connect to socket). Resolves when I/O channel is open. */
connect(): Promise<void>;
/** Write a string to the transport. Handles backpressure. */
write(data: string): Promise<void>;
/** Disconnect the transport. For stdio: kills the process. For socket: closes the connection. */
disconnect(): void;
/** Whether the transport is currently connected and writable. */
readonly connected: boolean;
}

3
ts/plugins.ts
View File

@@ -4,8 +4,9 @@ import * as fs from 'fs';
import * as childProcess from 'child_process';
import * as events from 'events';
import * as url from 'url';
import * as net from 'net';
export { path, fs, childProcess, events, url };
export { path, fs, childProcess, events, url, net };
// @push.rocks scope
import * as smartpath from '@push.rocks/smartpath';