@push.rocks/smartrust 1.2.1 → 1.3.1

package/test/test.sockettransport.node.ts

@@ -0,0 +1,312 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as childProcess from 'child_process';
+import * as os from 'os';
+import { RustBridge } from '../ts/classes.rustbridge.js';
+import type { ICommandDefinition } from '../ts/interfaces/index.js';
+
+const testDir = path.resolve(path.dirname(new URL(import.meta.url).pathname));
+const mockServerPath = path.join(testDir, 'helpers/mock-socket-server.mjs');
+
+// Define the command types for our mock binary
+type TMockCommands = {
+  echo: { params: Record<string, any>; result: Record<string, any> };
+  largeEcho: { params: Record<string, any>; result: Record<string, any> };
+  error: { params: {}; result: never };
+  emitEvent: { params: { eventName: string; eventData: any }; result: null };
+  slow: { params: {}; result: { delayed: boolean } };
+  exit: { params: {}; result: null };
+  streamEcho: { params: { count: number }; chunk: { index: number; value: string }; result: { totalChunks: number } };
+  streamError: { params: {}; chunk: { index: number; value: string }; result: never };
+  streamEmpty: { params: {}; chunk: never; result: { totalChunks: number } };
+};
+
+/**
+ * Start the mock socket server and return the socket path.
+ * Returns { proc, socketPath }.
+ */
+async function startMockServer(testName: string): Promise<{ proc: childProcess.ChildProcess; socketPath: string }> {
+  const socketPath = path.join(os.tmpdir(), `smartrust-test-${Date.now()}-${testName}.sock`);
+
+  const proc = childProcess.spawn('node', [mockServerPath, socketPath], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  // Wait for the server to signal readiness via stdout
+  return new Promise((resolve, reject) => {
+    let stdoutData = '';
+    const timeout = setTimeout(() => {
+      proc.kill();
+      reject(new Error('Mock server did not start within 5s'));
+    }, 5000);
+
+    proc.stdout!.on('data', (data: Buffer) => {
+      stdoutData += data.toString();
+      const lines = stdoutData.split('\n');
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const parsed = JSON.parse(line.trim());
+            if (parsed.ready) {
+              clearTimeout(timeout);
+              resolve({ proc, socketPath: parsed.socketPath });
+              return;
+            }
+          } catch { /* not JSON yet */ }
+        }
+      }
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+
+    proc.on('exit', (code) => {
+      clearTimeout(timeout);
+      reject(new Error(`Mock server exited with code ${code}`));
+    });
+  });
+}
+
+function stopMockServer(proc: childProcess.ChildProcess, socketPath: string) {
+  try { proc.kill('SIGTERM'); } catch { /* ignore */ }
+  try { fs.unlinkSync(socketPath); } catch { /* ignore */ }
+}
+
+// === Socket Transport Tests via RustBridge.connect() ===
+
+tap.test('socket: should connect and receive ready event', async () => {
+  const { proc, socketPath } = await startMockServer('connect-ready');
+  try {
+    const bridge = new RustBridge<TMockCommands>({
+      binaryName: 'mock-daemon',
+      readyTimeoutMs: 5000,
+    });
+
+    const result = await bridge.connect(socketPath);
+    expect(result).toBeTrue();
+    expect(bridge.running).toBeTrue();
+
+    bridge.kill();
+    expect(bridge.running).toBeFalse();
+  } finally {
+    stopMockServer(proc, socketPath);
+  }
+});
+
+tap.test('socket: should send command and receive response', async () => {
+  const { proc, socketPath } = await startMockServer('send-command');
+  try {
+    const bridge = new RustBridge<TMockCommands>({
+      binaryName: 'mock-daemon',
+      readyTimeoutMs: 5000,
+    });
+
+    await bridge.connect(socketPath);
+
+    const result = await bridge.sendCommand('echo', { hello: 'world', num: 42 });
+    expect(result).toEqual({ hello: 'world', num: 42 });
+
+    bridge.kill();
+  } finally {
+    stopMockServer(proc, socketPath);
+  }
+});
+
+tap.test('socket: should handle error responses', async () => {
+  const { proc, socketPath } = await startMockServer('error-response');
+  try {
+    const bridge = new RustBridge<TMockCommands>({
+      binaryName: 'mock-daemon',
+      readyTimeoutMs: 5000,
+    });
+
+    await bridge.connect(socketPath);
+
+    let threw = false;
+    try {
+      await bridge.sendCommand('error', {});
+    } catch (err: any) {
+      threw = true;
+      expect(err.message).toInclude('Test error message');
+    }
+    expect(threw).toBeTrue();
+
+    bridge.kill();
+  } finally {
+    stopMockServer(proc, socketPath);
+  }
+});
+
+tap.test('socket: should receive custom events', async () => {
+  const { proc, socketPath } = await startMockServer('custom-events');
+  try {
+    const bridge = new RustBridge<TMockCommands>({
+      binaryName: 'mock-daemon',
+      readyTimeoutMs: 5000,
+    });
+
+    await bridge.connect(socketPath);
+
+    const eventPromise = new Promise<any>((resolve) => {
+      bridge.once('management:testEvent', (data) => resolve(data));
+    });
+
+    await bridge.sendCommand('emitEvent', {
+      eventName: 'testEvent',
+      eventData: { key: 'value' },
+    });
+
+    const eventData = await eventPromise;
+    expect(eventData).toEqual({ key: 'value' });
+
+    bridge.kill();
+  } finally {
+    stopMockServer(proc, socketPath);
+  }
+});
+
+tap.test('socket: should handle multiple concurrent commands', async () => {
+  const { proc, socketPath } = await startMockServer('concurrent');
+  try {
+    const bridge = new RustBridge<TMockCommands>({
+      binaryName: 'mock-daemon',
+      readyTimeoutMs: 5000,
+    });
+
+    await bridge.connect(socketPath);
+
+    const results = await Promise.all([
+      bridge.sendCommand('echo', { id: 1 }),
+      bridge.sendCommand('echo', { id: 2 }),
+      bridge.sendCommand('echo', { id: 3 }),
+    ]);
+
+    expect(results[0]).toEqual({ id: 1 });
+    expect(results[1]).toEqual({ id: 2 });
+    expect(results[2]).toEqual({ id: 3 });
+
+    bridge.kill();
+  } finally {
+    stopMockServer(proc, socketPath);
+  }
+});
+
+tap.test('socket: should handle 1MB payload round-trip', async () => {
+  const { proc, socketPath } = await startMockServer('large-payload');
+  try {
+    const bridge = new RustBridge<TMockCommands>({
+      binaryName: 'mock-daemon',
+      readyTimeoutMs: 5000,
+      requestTimeoutMs: 30000,
+    });
+
+    await bridge.connect(socketPath);
+
+    const largeString = 'x'.repeat(1024 * 1024);
+    const result = await bridge.sendCommand('largeEcho', { data: largeString });
+    expect(result.data).toEqual(largeString);
+    expect(result.data.length).toEqual(1024 * 1024);
+
+    bridge.kill();
+  } finally {
+    stopMockServer(proc, socketPath);
+  }
+});
+
+tap.test('socket: should disconnect without killing the daemon', async () => {
+  const { proc, socketPath } = await startMockServer('no-kill-daemon');
+  try {
+    // First connection
+    const bridge1 = new RustBridge<TMockCommands>({
+      binaryName: 'mock-daemon',
+      readyTimeoutMs: 5000,
+    });
+    await bridge1.connect(socketPath);
+    expect(bridge1.running).toBeTrue();
+
+    // Disconnect
+    bridge1.kill();
+    expect(bridge1.running).toBeFalse();
+
+    // Second connection — daemon should still be alive
+    const bridge2 = new RustBridge<TMockCommands>({
+      binaryName: 'mock-daemon',
+      readyTimeoutMs: 5000,
+    });
+    const result = await bridge2.connect(socketPath);
+    expect(result).toBeTrue();
+    expect(bridge2.running).toBeTrue();
+
+    // Verify the daemon is functional
+    const echoResult = await bridge2.sendCommand('echo', { reconnected: true });
+    expect(echoResult).toEqual({ reconnected: true });
+
+    bridge2.kill();
+  } finally {
+    stopMockServer(proc, socketPath);
+  }
+});
+
+tap.test('socket: should stream responses via socket', async () => {
+  const { proc, socketPath } = await startMockServer('streaming');
+  try {
+    const bridge = new RustBridge<TMockCommands>({
+      binaryName: 'mock-daemon',
+      readyTimeoutMs: 5000,
+      requestTimeoutMs: 10000,
+    });
+
+    await bridge.connect(socketPath);
+
+    const stream = bridge.sendCommandStreaming('streamEcho', { count: 5 });
+    const chunks: Array<{ index: number; value: string }> = [];
+
+    for await (const chunk of stream) {
+      chunks.push(chunk);
+    }
+
+    expect(chunks.length).toEqual(5);
+    for (let i = 0; i < 5; i++) {
+      expect(chunks[i].index).toEqual(i);
+      expect(chunks[i].value).toEqual(`chunk_${i}`);
+    }
+
+    const result = await stream.result;
+    expect(result.totalChunks).toEqual(5);
+
+    bridge.kill();
+  } finally {
+    stopMockServer(proc, socketPath);
+  }
+});
+
+tap.test('socket: should return false when socket path does not exist', async () => {
+  const bridge = new RustBridge<TMockCommands>({
+    binaryName: 'mock-daemon',
+    readyTimeoutMs: 3000,
+  });
+
+  const result = await bridge.connect('/tmp/nonexistent-smartrust-test.sock');
+  expect(result).toBeFalse();
+  expect(bridge.running).toBeFalse();
+});
+
+tap.test('socket: should throw when sending command while not connected', async () => {
+  const bridge = new RustBridge<TMockCommands>({
+    binaryName: 'mock-daemon',
+  });
+
+  let threw = false;
+  try {
+    await bridge.sendCommand('echo', {});
+  } catch (err: any) {
+    threw = true;
+    expect(err.message).toInclude('not running');
+  }
+  expect(threw).toBeTrue();
+});
+
+export default tap.start();

package/ts/00_commitinfo_data.ts

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

package/ts/classes.linescanner.ts

@@ -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);
+  }
+}