tci-client-node 0.1.1 → 0.2.0

package/dist/transport/index.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from 'eventemitter3';
+import WebSocket from 'ws';
+
+interface TciTransportEvents {
+    connected: () => void;
+    disconnected: (reason?: unknown) => void;
+    text: (raw: string) => void;
+    binary: (raw: Buffer) => void;
+    error: (error: Error) => void;
+}
+interface TciTransport extends EventEmitter<TciTransportEvents> {
+    readonly url: string;
+    connect(timeoutMs: number): Promise<void>;
+    disconnect(code?: number, reason?: string): Promise<void>;
+    isConnected(): boolean;
+    sendText(raw: string): Promise<void>;
+    sendBinary(raw: Buffer): Promise<void>;
+    terminate(): void;
+}
+type TciTransportFactory = (url: string) => TciTransport;
+
+declare class WebSocketTciTransport extends EventEmitter<TciTransportEvents> implements TciTransport {
+    readonly url: string;
+    private readonly WebSocketImpl;
+    private socket?;
+    constructor(url: string, WebSocketImpl?: typeof WebSocket);
+    connect(timeoutMs: number): Promise<void>;
+    disconnect(code?: number, reason?: string): Promise<void>;
+    isConnected(): boolean;
+    sendText(raw: string): Promise<void>;
+    sendBinary(raw: Buffer): Promise<void>;
+    terminate(): void;
+    private attach;
+    private send;
+}
+
+export { type TciTransport, type TciTransportEvents, type TciTransportFactory, WebSocketTciTransport };

package/dist/transport/index.js

@@ -0,0 +1,138 @@
+// src/transport/WebSocketTransport.ts
+import { EventEmitter } from "eventemitter3";
+import WebSocket from "ws";
+
+// src/errors.ts
+var TciError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "TciError";
+    this.code = code;
+    this.details = details;
+  }
+};
+function toTciError(error, fallbackCode = "protocol-error") {
+  if (error instanceof TciError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new TciError(fallbackCode, error.message, error);
+  }
+  return new TciError(fallbackCode, String(error), error);
+}
+
+// src/transport/WebSocketTransport.ts
+var WebSocketTciTransport = class extends EventEmitter {
+  constructor(url, WebSocketImpl = WebSocket) {
+    super();
+    this.url = url;
+    this.WebSocketImpl = WebSocketImpl;
+  }
+  url;
+  WebSocketImpl;
+  socket;
+  async connect(timeoutMs) {
+    if (this.socket?.readyState === WebSocket.OPEN) return;
+    const socket = new this.WebSocketImpl(this.url);
+    this.socket = socket;
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        this.terminate();
+        reject(new TciError("connect-timeout", `Timed out connecting to ${this.url}`));
+      }, timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timer);
+        socket.off("open", onOpen);
+        socket.off("close", onCloseBeforeOpen);
+        socket.off("error", onErrorBeforeOpen);
+      };
+      const onOpen = () => {
+        cleanup();
+        this.attach(socket);
+        this.emit("connected");
+        resolve();
+      };
+      const onCloseBeforeOpen = () => {
+        cleanup();
+        reject(new TciError("disconnected", `Disconnected while connecting to ${this.url}`));
+      };
+      const onErrorBeforeOpen = (error) => {
+        cleanup();
+        reject(toTciError(error, "disconnected"));
+      };
+      socket.once("open", onOpen);
+      socket.once("close", onCloseBeforeOpen);
+      socket.once("error", onErrorBeforeOpen);
+    });
+  }
+  async disconnect(code = 1e3, reason = "client disconnect") {
+    const socket = this.socket;
+    if (!socket || socket.readyState === WebSocket.CLOSED) return;
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, 1e3);
+      timer.unref?.();
+      socket.once("close", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      socket.once("error", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      socket.close(code, reason);
+    });
+  }
+  isConnected() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+  async sendText(raw) {
+    await this.send(raw);
+  }
+  async sendBinary(raw) {
+    await this.send(raw, true);
+  }
+  terminate() {
+    try {
+      this.socket?.terminate();
+    } catch {
+    }
+  }
+  attach(socket) {
+    socket.on("message", (data, isBinary) => {
+      try {
+        const buffer = dataToBuffer(data);
+        if (isBinary) this.emit("binary", buffer);
+        else this.emit("text", buffer.toString("utf8"));
+      } catch (error) {
+        this.emit("error", error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+    socket.on("close", (code, reason) => {
+      if (this.socket === socket) this.socket = void 0;
+      this.emit("disconnected", { code, reason: reason.toString("utf8") });
+    });
+    socket.on("error", (error) => this.emit("error", error));
+  }
+  async send(data, binary = false) {
+    const socket = this.socket;
+    if (!socket || socket.readyState !== WebSocket.OPEN) {
+      throw new TciError("not-connected", "TCI socket is not connected");
+    }
+    await new Promise((resolve, reject) => {
+      socket.send(data, { binary }, (error) => error ? reject(error) : resolve());
+    });
+  }
+};
+function dataToBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (data instanceof ArrayBuffer) return Buffer.from(data);
+  if (Array.isArray(data)) return Buffer.concat(data.map((item) => dataToBuffer(item)));
+  throw new TciError("protocol-error", "Unsupported WebSocket data type");
+}
+export {
+  WebSocketTciTransport
+};
+//# sourceMappingURL=index.js.map

package/dist/transport/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transport/WebSocketTransport.ts","../../src/errors.ts"],"sourcesContent":["import { EventEmitter } from 'eventemitter3';\nimport WebSocket from 'ws';\nimport { TciError, toTciError } from '../errors.js';\nimport type { TciTransport, TciTransportEvents } from './types.js';\n\nexport class WebSocketTciTransport extends EventEmitter<TciTransportEvents> implements TciTransport {\n  private socket?: WebSocket;\n\n  constructor(readonly url: string, private readonly WebSocketImpl: typeof WebSocket = WebSocket) {\n    super();\n  }\n\n  async connect(timeoutMs: number): Promise<void> {\n    if (this.socket?.readyState === WebSocket.OPEN) return;\n    const socket = new this.WebSocketImpl(this.url);\n    this.socket = socket;\n    await new Promise<void>((resolve, reject) => {\n      const timer = setTimeout(() => {\n        cleanup();\n        this.terminate();\n        reject(new TciError('connect-timeout', `Timed out connecting to ${this.url}`));\n      }, timeoutMs);\n      const cleanup = () => {\n        clearTimeout(timer);\n        socket.off('open', onOpen);\n        socket.off('close', onCloseBeforeOpen);\n        socket.off('error', onErrorBeforeOpen);\n      };\n      const onOpen = () => {\n        cleanup();\n        this.attach(socket);\n        this.emit('connected');\n        resolve();\n      };\n      const onCloseBeforeOpen = () => {\n        cleanup();\n        reject(new TciError('disconnected', `Disconnected while connecting to ${this.url}`));\n      };\n      const onErrorBeforeOpen = (error: Error) => {\n        cleanup();\n        reject(toTciError(error, 'disconnected'));\n      };\n      socket.once('open', onOpen);\n      socket.once('close', onCloseBeforeOpen);\n      socket.once('error', onErrorBeforeOpen);\n    });\n  }\n\n  async disconnect(code = 1000, reason = 'client disconnect'): Promise<void> {\n    const socket = this.socket;\n    if (!socket || socket.readyState === WebSocket.CLOSED) return;\n    await new Promise<void>((resolve) => {\n      const timer = setTimeout(resolve, 1_000);\n      timer.unref?.();\n      socket.once('close', () => { clearTimeout(timer); resolve(); });\n      socket.once('error', () => { clearTimeout(timer); resolve(); });\n      socket.close(code, reason);\n    });\n  }\n\n  isConnected(): boolean { return this.socket?.readyState === WebSocket.OPEN; }\n\n  async sendText(raw: string): Promise<void> { await this.send(raw); }\n  async sendBinary(raw: Buffer): Promise<void> { await this.send(raw, true); }\n\n  terminate(): void {\n    try { this.socket?.terminate(); } catch { /* ignore termination races */ }\n  }\n\n  private attach(socket: WebSocket): void {\n    socket.on('message', (data, isBinary) => {\n      try {\n        const buffer = dataToBuffer(data);\n        if (isBinary) this.emit('binary', buffer);\n        else this.emit('text', buffer.toString('utf8'));\n      } catch (error) {\n        this.emit('error', error instanceof Error ? error : new Error(String(error)));\n      }\n    });\n    socket.on('close', (code, reason) => {\n      if (this.socket === socket) this.socket = undefined;\n      this.emit('disconnected', { code, reason: reason.toString('utf8') });\n    });\n    socket.on('error', (error) => this.emit('error', error));\n  }\n\n  private async send(data: string | Buffer, binary = false): Promise<void> {\n    const socket = this.socket;\n    if (!socket || socket.readyState !== WebSocket.OPEN) {\n      throw new TciError('not-connected', 'TCI socket is not connected');\n    }\n    await new Promise<void>((resolve, reject) => {\n      socket.send(data, { binary }, (error) => error ? reject(error) : resolve());\n    });\n  }\n}\n\nfunction dataToBuffer(data: WebSocket.RawData): Buffer {\n  if (Buffer.isBuffer(data)) return data;\n  if (data instanceof ArrayBuffer) return Buffer.from(data);\n  if (Array.isArray(data)) return Buffer.concat(data.map((item) => dataToBuffer(item)));\n  throw new TciError('protocol-error', 'Unsupported WebSocket data type');\n}\n","export type TciErrorCode =\n  | 'connect-timeout'\n  | 'handshake-timeout'\n  | 'invalid-handshake'\n  | 'unknown-dialect'\n  | 'command-timeout'\n  | 'not-connected'\n  | 'disconnected'\n  | 'protocol-error'\n  | 'invalid-frame'\n  | 'cancelled';\n\nexport class TciError extends Error {\n  readonly code: TciErrorCode;\n  readonly details?: unknown;\n\n  constructor(code: TciErrorCode, message: string, details?: unknown) {\n    super(message);\n    this.name = 'TciError';\n    this.code = code;\n    this.details = details;\n  }\n}\n\nexport function toTciError(error: unknown, fallbackCode: TciErrorCode = 'protocol-error'): TciError {\n  if (error instanceof TciError) {\n    return error;\n  }\n  if (error instanceof Error) {\n    return new TciError(fallbackCode, error.message, error);\n  }\n  return new TciError(fallbackCode, String(error), error);\n}\n"],"mappings":"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","names":[]}

package/dist/types-9seY9Th-.d.ts

@@ -0,0 +1,63 @@
+import { T as TciCommand } from './text-BwCWY1k1.js';
+
+type BuiltInTciDialectId = 'expertsdr-1.4' | 'expertsdr-1.5-1.8' | 'expertsdr-1.9-2.0' | 'aethersdr-1.5' | 'thetis-2.0' | 'generic-observed';
+type TciDialectId = BuiltInTciDialectId | (string & {
+    readonly __tciDialectId?: never;
+});
+type TciDialectSelection = 'auto' | TciDialectId | TciDialect;
+type TciStreamLengthSemantics = 'scalar' | 'per-channel' | 'auto';
+interface TciProtocolIdentity {
+    programName?: string;
+    protocolVersion?: string;
+    rawProtocolArgs: string[];
+    device?: string;
+}
+interface TciDialectDetectionContext {
+    identity: TciProtocolIdentity;
+    commands: readonly TciCommand[];
+    commandNames: ReadonlySet<string>;
+}
+interface TciDialectScore {
+    score: number;
+    evidence: string[];
+    warnings?: string[];
+}
+interface TciDriveState {
+    trx: number;
+    value: number;
+}
+interface TciDialect {
+    readonly id: TciDialectId;
+    readonly label: string;
+    readonly streamLengthSemantics: TciStreamLengthSemantics;
+    readonly supportsStreamChannels: boolean;
+    readonly supportsTxAudioSource: boolean;
+    detect(context: TciDialectDetectionContext): TciDialectScore;
+    resolve?(context: TciDialectDetectionContext): TciDialect;
+    buildDriveSetArgs(trx: number, value: number): readonly unknown[];
+    buildDriveReadArgs(trx: number): readonly unknown[];
+    parseDrive(args: readonly string[], defaultTrx: number): TciDriveState | undefined;
+    buildTuneDriveSetArgs(trx: number, value: number): readonly unknown[];
+    buildTuneDriveReadArgs(trx: number): readonly unknown[];
+    parseTuneDrive(args: readonly string[], defaultTrx: number): TciDriveState | undefined;
+}
+interface TciDialectDetection {
+    dialect: TciDialect;
+    confidence: 'manual' | 'high' | 'medium' | 'low';
+    evidence: string[];
+    warnings: string[];
+}
+interface TciHandshakeResult {
+    identity: TciProtocolIdentity;
+    dialect: TciDialectDetection;
+    ready: true;
+    commandNames: string[];
+}
+interface TciWriteResult<T> {
+    requested: T;
+    applied: T;
+    outcome: 'applied' | 'clamped';
+    acknowledgement: 'state' | 'reply' | 'readback';
+}
+
+export type { BuiltInTciDialectId as B, TciDialectId as T, TciHandshakeResult as a, TciDialectSelection as b, TciWriteResult as c, TciDialect as d, TciDialectDetection as e, TciDialectDetectionContext as f, TciDialectScore as g, TciDriveState as h, TciProtocolIdentity as i, TciStreamLengthSemantics as j };

package/dist/types-xRotf9gW.d.cts

@@ -0,0 +1,63 @@
+import { T as TciCommand } from './text-BwCWY1k1.cjs';
+
+type BuiltInTciDialectId = 'expertsdr-1.4' | 'expertsdr-1.5-1.8' | 'expertsdr-1.9-2.0' | 'aethersdr-1.5' | 'thetis-2.0' | 'generic-observed';
+type TciDialectId = BuiltInTciDialectId | (string & {
+    readonly __tciDialectId?: never;
+});
+type TciDialectSelection = 'auto' | TciDialectId | TciDialect;
+type TciStreamLengthSemantics = 'scalar' | 'per-channel' | 'auto';
+interface TciProtocolIdentity {
+    programName?: string;
+    protocolVersion?: string;
+    rawProtocolArgs: string[];
+    device?: string;
+}
+interface TciDialectDetectionContext {
+    identity: TciProtocolIdentity;
+    commands: readonly TciCommand[];
+    commandNames: ReadonlySet<string>;
+}
+interface TciDialectScore {
+    score: number;
+    evidence: string[];
+    warnings?: string[];
+}
+interface TciDriveState {
+    trx: number;
+    value: number;
+}
+interface TciDialect {
+    readonly id: TciDialectId;
+    readonly label: string;
+    readonly streamLengthSemantics: TciStreamLengthSemantics;
+    readonly supportsStreamChannels: boolean;
+    readonly supportsTxAudioSource: boolean;
+    detect(context: TciDialectDetectionContext): TciDialectScore;
+    resolve?(context: TciDialectDetectionContext): TciDialect;
+    buildDriveSetArgs(trx: number, value: number): readonly unknown[];
+    buildDriveReadArgs(trx: number): readonly unknown[];
+    parseDrive(args: readonly string[], defaultTrx: number): TciDriveState | undefined;
+    buildTuneDriveSetArgs(trx: number, value: number): readonly unknown[];
+    buildTuneDriveReadArgs(trx: number): readonly unknown[];
+    parseTuneDrive(args: readonly string[], defaultTrx: number): TciDriveState | undefined;
+}
+interface TciDialectDetection {
+    dialect: TciDialect;
+    confidence: 'manual' | 'high' | 'medium' | 'low';
+    evidence: string[];
+    warnings: string[];
+}
+interface TciHandshakeResult {
+    identity: TciProtocolIdentity;
+    dialect: TciDialectDetection;
+    ready: true;
+    commandNames: string[];
+}
+interface TciWriteResult<T> {
+    requested: T;
+    applied: T;
+    outcome: 'applied' | 'clamped';
+    acknowledgement: 'state' | 'reply' | 'readback';
+}
+
+export type { BuiltInTciDialectId as B, TciDialectId as T, TciHandshakeResult as a, TciDialectSelection as b, TciWriteResult as c, TciDialect as d, TciDialectDetection as e, TciDialectDetectionContext as f, TciDialectScore as g, TciDriveState as h, TciProtocolIdentity as i, TciStreamLengthSemantics as j };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "tci-client-node",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Pure TypeScript TCI (Transceiver Control Interface) client for SunSDR/ExpertSDR.",
   "type": "module",
   "license": "MIT",
   "author": "boybook",
+  "engines": {
+    "node": ">=20"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/boybook/tci-client-node.git"
@@ -26,6 +29,7 @@
   "files": [
     "dist",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "main": "./dist/index.cjs",
@@ -63,6 +67,16 @@
       "import": "./dist/audio/index.js",
       "require": "./dist/audio/index.cjs"
     },
+    "./dialect": {
+      "types": "./dist/dialect/index.d.ts",
+      "import": "./dist/dialect/index.js",
+      "require": "./dist/dialect/index.cjs"
+    },
+    "./transport": {
+      "types": "./dist/transport/index.d.ts",
+      "import": "./dist/transport/index.js",
+      "require": "./dist/transport/index.cjs"
+    },
     "./testing": {
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.js",