@robotical/raftjs 2.1.2 → 2.1.3

package/examples/dashboard/src/DeviceActionsForm.tsx

@@ -15,6 +15,20 @@ function findClosest(arr: number[], target: number): number {
     );
 }
 
+function getDefaultActionValue(action: DeviceTypeAction): number {
+    if (action.d !== undefined) {
+        return action.d;
+    }
+    if (action.map) {
+        const firstMapKey = Object.keys(action.map).sort((a, b) => parseFloat(a) - parseFloat(b))[0];
+        return firstMapKey !== undefined ? parseFloat(firstMapKey) : 0;
+    }
+    if (action.r && action.r.length > 1) {
+        return (action.r[1] + action.r[0]) / 2;
+    }
+    return 0;
+}
+
 type DeviceActionsTableProps = {
     deviceKey: string;
 };
@@ -51,13 +65,7 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
             setHasConfRate(!!confRateAction);
             // Initialize input values with defaults
             const initialValues: InputValues = actions.reduce((acc, action) => {
-                acc[action.n] =
-                    action.d ??
-                    (action.r
-                        ? action.r.length > 1
-                            ? (action.r[1] + action.r[0]) / 2
-                            : 0
-                        : 0);
+                acc[action.n] = getDefaultActionValue(action);
                 return acc;
             }, {} as InputValues);
 
@@ -183,12 +191,13 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
                             const mapKeys = Object.keys(action.map).sort((a, b) => parseFloat(a) - parseFloat(b));
                             // Use "Rate Hz" label for _conf.rate actions
                             const actionLabel = action.n === '_conf.rate' ? 'Rate Hz' : (action.desc ?? action.n);
+                            const actionValue = inputValues[action.n] ?? getDefaultActionValue(action);
                             return (
                                 <tr key={action.n}>
                                     <td>{actionLabel}</td>
                                     <td>
                                         <select
-                                            value={inputValues[action.n]}
+                                            value={actionValue}
                                             onChange={(e) =>
                                                 handleInputChange(
                                                     action.n,
@@ -208,7 +217,7 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
                                             onClick={() =>
                                                 handleSendAction(
                                                     action,
-                                                    inputValues[action.n]
+                                                    actionValue
                                                 )
                                             }
                                         >
@@ -218,6 +227,7 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
                                 </tr>
                             );
                         } else {
+                            const actionValue = inputValues[action.n] ?? getDefaultActionValue(action);
                             return (
                                 <tr key={action.n}>
                                     <td>{action.n}</td>
@@ -227,7 +237,7 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
                                                 type="number"
                                                 min={action.r?.[0] ?? 0}
                                                 max={action.r?.[1] ?? 100}
-                                                value={inputValues[action.n]}
+                                                value={actionValue}
                                                 onChange={(e) =>
                                                     handleInputChange(
                                                         action.n,
@@ -242,7 +252,7 @@ const DeviceActionsForm: React.FC<DeviceActionsTableProps> = ({ deviceKey }: Dev
                                             onClick={() =>
                                                 handleSendAction(
                                                     action,
-                                                    inputValues[action.n]
+                                                    actionValue
                                                 )
                                             }
                                         >

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robotical/raftjs",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "Javascript/TS library for Raft library",
   "main": "dist/web/main.js",
   "types": "dist/web/main.d.ts",

package/src/RaftConnector.ts

@@ -14,7 +14,7 @@ import RaftChannelWebSocket from "./RaftChannelWebSocket";
 import RaftChannelWebSerial from "./RaftChannelWebSerial";
 import RaftChannelSimulated from "./RaftChannelSimulated";
 import RaftCommsStats from "./RaftCommsStats";
-import { RaftEventFn, RaftOKFail, RaftFileSendType, RaftFileDownloadResult, RaftProgressCBType, RaftStreamDataProgressCBType, RaftBridgeSetupResp, RaftFileDownloadFn, RaftReportMsg } from "./RaftTypes";
+import { RaftEventFn, RaftOKFail, RaftFileSendType, RaftFileDownloadResult, RaftProgressCBType, RaftStreamDataProgressCBType, RaftBridgeSetupResp, RaftFileDownloadFn, RaftReportMsg, RaftRtStreamDataCBType, RaftRtStreamHandle, RaftRtStreamOptions, RaftRtStreamStartResp } from "./RaftTypes";
 import RaftSystemUtils from "./RaftSystemUtils";
 import RaftFileHandler from "./RaftFileHandler";
 import RaftStreamHandler from "./RaftStreamHandler";
@@ -87,6 +87,10 @@ export default class RaftConnector {
   // Update manager
   private _raftUpdateManager: RaftUpdateManager | null = null;
 
+  // Open-ended RT stream callbacks keyed by streamID
+  private _rtStreamCallbacks = new Map<number, RaftRtStreamDataCBType>();
+  private _fallbackRtStreamCallback: { streamID: number, callback: RaftRtStreamDataCBType } | null = null;
+
   /**
    * RaftConnector constructor
    * @param getSystemTypeCB - callback to get system type
@@ -193,6 +197,22 @@ export default class RaftConnector {
     return this._commsStats;
   }
 
+  /**
+   * getOperationQueueDepth
+   * @returns number of high-level device operations queued or running
+   */
+  getOperationQueueDepth(): number {
+    return 0;
+  }
+
+  /**
+   * isOperationBusy
+   * @returns true when a high-level device operation is queued or running
+   */
+  isOperationBusy(): boolean {
+    return false;
+  }
+
   /**
    * Get Raft message handler (to allow message sending and receiving)
    * @returns RaftMsgHandler - Raft message handler
@@ -408,6 +428,11 @@ export default class RaftConnector {
    *
    */
   async sendRICRESTMsg(commandName: string, params: object,
+    bridgeID: number | undefined = undefined): Promise<RaftOKFail> {
+    return this._sendRICRESTMsg(commandName, params, bridgeID);
+  }
+
+  private async _sendRICRESTMsg(commandName: string, params: object,
     bridgeID: number | undefined = undefined): Promise<RaftOKFail> {
     try {
       // Format the paramList as query string
@@ -415,11 +440,12 @@ export default class RaftConnector {
       let paramQueryStr = '';
       for (const param of paramEntries) {
         if (paramQueryStr.length > 0) paramQueryStr += '&';
-        paramQueryStr += param[0] + '=' + param[1];
+        paramQueryStr += `${encodeURIComponent(param[0])}=${encodeURIComponent(String(param[1]))}`;
       }
       // Format the url to send
       if (paramQueryStr.length > 0) commandName += '?' + paramQueryStr;
-      return await this._raftMsgHandler.sendRICRESTURL<RaftOKFail>(commandName, bridgeID);
+      const response = await this._raftMsgHandler.sendRICRESTURL<RaftOKFail | null>(commandName, bridgeID);
+      return response ?? { rslt: 'fail' };
     } catch (error) {
       RaftLog.warn(`sendRICRESTMsg failed ${error}`);
       return { rslt: 'fail' };
@@ -473,6 +499,13 @@ export default class RaftConnector {
     fileBlockData: Uint8Array
   ): void {
     // RaftLog.info(`onRxFileBlock filePos ${filePos} fileBlockData ${RaftUtils.bufferToHex(fileBlockData)}`);
+    const streamID = (filePos >>> 24) & 0xff;
+    const streamFilePos = filePos & 0x00ffffff;
+    const streamCallback = this._rtStreamCallbacks.get(streamID);
+    if (streamID !== 0 && streamCallback) {
+      streamCallback(fileBlockData, streamFilePos, streamID);
+      return;
+    }
     this._raftFileHandler.onFileBlock(filePos, fileBlockData);
   }
 
@@ -534,6 +567,82 @@ export default class RaftConnector {
     return false;
   }
 
+  /**
+   * openRtStream - open an indefinite bidirectional RT stream.
+   * The returned handle can send byte blocks and closes with ufEnd.
+   */
+  async openRtStream(options: RaftRtStreamOptions): Promise<RaftRtStreamHandle> {
+    const cmdMsg = JSON.stringify({
+      cmdName: "ufStart",
+      reqStr: "ufStart",
+      fileType: "rtstream",
+      fileName: options.fileName,
+      endpoint: options.endpoint,
+      fileLen: 0,
+    });
+
+    const startResp = await this._raftMsgHandler.sendRICRESTCmdFrame<RaftRtStreamStartResp>(cmdMsg);
+    if (!startResp || startResp.rslt !== "ok" || startResp.streamID === undefined) {
+      throw new Error(`openRtStream failed ${startResp?.rslt ?? "no response"}`);
+    }
+
+    const streamID = startResp.streamID;
+    const maxBlockSize = startResp.maxBlockSize || this._raftStreamHandler.maxBlockSize;
+    let txFilePos = 0;
+    let sendQueue = Promise.resolve();
+    this._rtStreamCallbacks.set(streamID, options.onData);
+    this._fallbackRtStreamCallback = { streamID, callback: options.onData };
+
+    const sendBytes = async (bytes: Uint8Array): Promise<boolean> => {
+      let sentOk = false;
+      sendQueue = sendQueue
+        .catch(() => {
+          // Keep later terminal input flowing even if an earlier block failed.
+        })
+        .then(async () => {
+          sentOk = await this._raftMsgHandler.sendStreamBlock(bytes, txFilePos, streamID);
+          if (sentOk) {
+            txFilePos = (txFilePos + bytes.length) & 0x00ffffff;
+          }
+        });
+      await sendQueue;
+      return sentOk;
+    };
+
+    const close = async (): Promise<boolean> => {
+      this._rtStreamCallbacks.delete(streamID);
+      if (this._fallbackRtStreamCallback?.streamID === streamID) {
+        this._fallbackRtStreamCallback = null;
+      }
+      const endMsg = JSON.stringify({
+        cmdName: "ufEnd",
+        reqStr: "ufEnd",
+        streamID,
+      });
+      try {
+        const endResp = await this._raftMsgHandler.sendRICRESTCmdFrame<RaftOKFail>(endMsg);
+        return endResp?.rslt === "ok";
+      } catch (error) {
+        RaftLog.warn(`closeRtStream failed ${streamID}: ${error}`);
+        return false;
+      }
+    };
+
+    // Some endpoints use an initial empty block as an attach signal.
+    // Keep this opt-in because older endpoints reject zero-length ufBlock frames.
+    if (options.sendInitialEmptyBlock) {
+      await sendBytes(new Uint8Array());
+    }
+
+    return {
+      streamID,
+      maxBlockSize,
+      sendBytes,
+      sendText: (text: string) => sendBytes(new TextEncoder().encode(text)),
+      close,
+    };
+  }
+
   /**
    * streamAudio - stream audio
    * @param streamContents audio data

package/src/RaftFileHandler.ts

@@ -65,6 +65,7 @@ export default class RaftFileHandler {
   private _ackedFilePos = 0;
   private _batchAckReceived = false;
   private _isTxCancelled = false;
+  private _fileTxStreamID = 0;
 
   // File receive info
   private _isRxCancelled = false;
@@ -110,6 +111,7 @@ export default class RaftFileHandler {
     progressCallback: ((sent: number, total: number, progress: number) => void) | undefined,
   ): Promise<boolean> {
     this._isTxCancelled = false;
+    this._fileTxStreamID = 0;
 
     // Send file start message
     if (!await this._sendFileStartMsg(fileName, fileType, fileDest, fileContents))
@@ -165,8 +167,8 @@ export default class RaftFileHandler {
       RaftLog.warn(`sendFileStartMsg error ${err}`);
       return false;
     }
-    if (fileStartResp.rslt !== 'ok') {
-      RaftLog.warn(`sendFileStartMsg error ${fileStartResp.rslt}`);
+    if (!fileStartResp || fileStartResp.rslt !== 'ok') {
+      RaftLog.warn(`sendFileStartMsg error ${fileStartResp?.rslt ?? 'no response'}`);
       return false;
     }
 
@@ -181,12 +183,17 @@ export default class RaftFileHandler {
     } else {
       this._batchAckSize = this._requestedBatchAckSize;
     }
+    const streamID = fileStartResp.streamID;
+    this._fileTxStreamID = streamID !== undefined && streamID > 0 && streamID <= 0xff ? streamID : 0;
     RaftLog.debug(
       `_fileSendStartMsg fileBlockSize req ${this._requestedFileBlockSize} resp ${fileStartResp.batchMsgSize} actual ${this._fileBlockSize}`,
     );
     RaftLog.debug(
       `_fileSendStartMsg batchAckSize req ${this._requestedBatchAckSize} resp ${fileStartResp.batchAckSize} actual ${this._batchAckSize}`,
     );
+    RaftLog.debug(
+      `_fileSendStartMsg streamID ${this._fileTxStreamID}`,
+    );
     return true;
   }
 
@@ -202,7 +209,8 @@ export default class RaftFileHandler {
         ? 'espfwupdate'
         : 'fileupload';
     const fileLen = fileContents.length;
-    const cmdMsg = `{"cmdName":"ufEnd","reqStr":"${reqStr}","fileType":"${fileDest}","fileName":"${fileName}","fileLen":${fileLen}}`;
+    const streamIDJson = this._fileTxStreamID !== 0 ? `,"streamID":${this._fileTxStreamID}` : '';
+    const cmdMsg = `{"cmdName":"ufEnd","reqStr":"${reqStr}","fileType":"${fileDest}","fileName":"${fileName}","fileLen":${fileLen}${streamIDJson}}`;
 
     // Await outstanding promises
     try {
@@ -223,12 +231,13 @@ export default class RaftFileHandler {
       RaftLog.warn(`sendFileEndMsg error ${err}`);
       return false;
     }
-    return fileEndResp.rslt === 'ok';
+    return fileEndResp?.rslt === 'ok';
   }
 
   async _sendFileCancelMsg(): Promise<void> {
     // File cancel command message
-    const cmdMsg = `{"cmdName":"ufCancel"}`;
+    const streamIDJson = this._fileTxStreamID !== 0 ? `,"streamID":${this._fileTxStreamID}` : '';
+    const cmdMsg = `{"cmdName":"ufCancel"${streamIDJson}}`;
 
     // Await outstanding promises
     await this.awaitOutstandingMsgPromises(true);
@@ -367,7 +376,7 @@ export default class RaftFileHandler {
     await this.awaitOutstandingMsgPromises(false);
 
     // Send
-    const promRslt = this._msgHandler.sendFileBlock(fileContents.subarray(blockStart, blockEnd), blockStart);
+    const promRslt = this._msgHandler.sendFileBlock(fileContents.subarray(blockStart, blockEnd), blockStart, this._fileTxStreamID);
     if (!promRslt) {
       return false;
     }
@@ -437,8 +446,8 @@ export default class RaftFileHandler {
       // Establish a bridge
       const bridgedDeviceSerialPort = "Serial" + fileSource.slice(bridgeSerialPrefix.length);
       const cmdResp = await this._msgHandler.createCommsBridge(bridgedDeviceSerialPort, "fileSource");
-      if (cmdResp.rslt != "ok") {
-        RaftLog.warn(`fileReceive - failed to setup bridge ${cmdResp.rslt}`);
+      if (!cmdResp || cmdResp.rslt != "ok") {
+        RaftLog.warn(`fileReceive - failed to setup bridge ${cmdResp?.rslt ?? 'no response'}`);
         return new RaftFileDownloadResult();
       }
       bridgeID = cmdResp.bridgeID;
@@ -497,7 +506,7 @@ export default class RaftFileHandler {
       return false;
     }
     RaftLog.info(`_receiveFileStartMsg rslt ${JSON.stringify(cmdResp)}`);
-    if (cmdResp.rslt === 'ok') {
+    if (cmdResp?.rslt === 'ok') {
       this._fileRxBatchMsgSize = cmdResp.batchMsgSize;
       this._fileRxBatchAckSize = cmdResp.batchAckSize;
       this._fileRxStreamID = cmdResp.streamID;
@@ -510,6 +519,10 @@ export default class RaftFileHandler {
       this._fileRxLastBlockTime = Date.now();
       this._fileRxActive = true;
     }
+    if (!cmdResp) {
+      RaftLog.warn(`_receiveFileStartMsg failed no response`);
+      return false;
+    }
     return cmdResp.rslt === 'ok';
   }
 
@@ -580,6 +593,7 @@ export default class RaftFileHandler {
               `elapsed ${now - startTime}ms overallTimeout ${overallTimeoutMs}ms ` +
               `blockGap ${now - this._fileRxLastBlockTime}ms blockTimeout ${blockTimeoutMs}ms`);
           this._fileRxActive = false;
+          this._sendFileRxCancelMsg(bridgeID);
           reject(new Error('fileReceive failed'));
           return;
         }
@@ -651,6 +665,12 @@ export default class RaftFileHandler {
     }
 
     // Check deferred CRC if start response didn't include one
+    if (!cmdResp) {
+      RaftLog.warn(`_receiveFileEnd failed no response`);
+      this._fileRxActive = false;
+      return false;
+    }
+
     if (this._fileRxCrc16 < 0 && cmdResp.crc16) {
       const expectedCrc = parseInt(cmdResp.crc16, 16);
       const actualCrc = RaftMiniHDLC.crc16(this._fileRxBuffer);
@@ -683,8 +703,20 @@ export default class RaftFileHandler {
   ): void {
     // RaftLog.info(`onFileBlock filePos ${filePos} fileBlockData ${RaftUtils.bufferToHex(fileBlockData)}`);
 
+    if (!this._fileRxActive) {
+      RaftLog.verbose(`onFileBlock ignored inactive transfer filePos ${filePos} len ${fileBlockData.length}`);
+      return;
+    }
+
+    const streamID = (filePos >>> 24) & 0xff;
+    const streamFilePos = filePos & 0x00ffffff;
+    if (streamID !== 0 && streamID !== this._fileRxStreamID) {
+      RaftLog.verbose(`onFileBlock ignored stale streamID ${streamID} active ${this._fileRxStreamID}`);
+      return;
+    }
+
     // Check if this is the next block we are expecting
-    if (filePos === this._fileRxBuffer.length) {
+    if (streamFilePos === this._fileRxBuffer.length) {
 
       // Add to buffer
       const tmpArray = new Uint8Array(this._fileRxBuffer.length + fileBlockData.length);
@@ -699,7 +731,7 @@ export default class RaftFileHandler {
       // RaftLog.info(`onFileBlock filePos ${filePos} fileBlockData ${RaftUtils.bufferToHex(fileBlockData)} added to buffer`);
 
     } else {
-      RaftLog.warn(`onFileBlock expected streamID ${this._fileRxStreamID} filePos ${filePos} fileBlockData ${RaftUtils.bufferToHex(fileBlockData)} out of sequence`);
+      RaftLog.warn(`onFileBlock expected streamID ${this._fileRxStreamID} filePos ${streamFilePos} fileBlockData ${RaftUtils.bufferToHex(fileBlockData)} out of sequence`);
     }
   }
 

package/src/RaftMicroPythonConsoleClient.ts

@@ -0,0 +1,78 @@
+import RaftConnector from "./RaftConnector";
+import { RaftRtStreamDataCBType, RaftRtStreamHandle } from "./RaftTypes";
+
+const REPL_NEWLINE = "\r";
+
+export type RaftMicroPythonConsoleStatus = {
+  rslt?: string;
+  running?: string;
+  replEnabled?: boolean;
+  replRunning?: boolean;
+  mode?: string;
+  streamAttached?: boolean;
+  mirrorToSerial?: boolean;
+  inputBuffered?: number;
+  outputBuffered?: number;
+  outputSeq?: number;
+  inputDropped?: number;
+  outputDropped?: number;
+};
+
+export type RaftMicroPythonConsoleOutput = {
+  rslt?: string;
+  seq?: number;
+  missed?: number;
+  dropped?: number;
+  data?: string;
+};
+
+export default class RaftMicroPythonConsoleClient {
+  constructor(private _connector: RaftConnector) {}
+  private readonly _streamDrainMs = 1200;
+
+  async status(): Promise<RaftMicroPythonConsoleStatus> {
+    return this._connector.sendRICRESTMsg("upy/repl/status", {}) as Promise<RaftMicroPythonConsoleStatus>;
+  }
+
+  async output(since: number): Promise<RaftMicroPythonConsoleOutput> {
+    return this._connector.sendRICRESTMsg("upy/repl/output", { since }) as Promise<RaftMicroPythonConsoleOutput>;
+  }
+
+  async input(data: string, newline = true): Promise<{ rslt?: string }> {
+    const payload = newline ? `${data}${REPL_NEWLINE}` : data;
+    return this._connector.sendRICRESTMsg(
+      `upy/repl/input?data=${payload}&newline=0`,
+      {}
+    ) as Promise<{ rslt?: string }>;
+  }
+
+  async interrupt(): Promise<{ rslt?: string }> {
+    return this._connector.sendRICRESTMsg("upy/repl/interrupt", {}) as Promise<{ rslt?: string }>;
+  }
+
+  async openStream(onData: RaftRtStreamDataCBType): Promise<RaftRtStreamHandle> {
+    return this._connector.openRtStream({
+      fileName: "upyconsole",
+      endpoint: "upyconsole",
+      onData,
+    });
+  }
+
+  async streamInput(
+    data: string,
+    newline = true,
+    onData: RaftRtStreamDataCBType = () => {}
+  ): Promise<boolean> {
+    const payload = newline ? `${data}${REPL_NEWLINE}` : data;
+    const streamHandle = await this.openStream(onData);
+    try {
+      return await streamHandle.sendText(payload);
+    } finally {
+      setTimeout(() => {
+        streamHandle.close().catch(() => {
+          // The firmware may close short-lived console sessions first.
+        });
+      }, this._streamDrainMs);
+    }
+  }
+}

package/src/RaftMsgHandler.ts

@@ -269,8 +269,11 @@ export default class RaftMsgHandler {
         }
 
       } else {
-        RaftLog.warn(
-          `_handleResponseMessages RICREST response doesn't contain rslt ${rxMsgNum == 0 ? "unnumbered" : "msgNum " + rxMsgNum.toString()}resp ${restStr}`,
+        // Some REST APIs return data-only JSON, including an empty object, with no rslt field.
+        // Treat parseable JSON as a successful transport response and let callers interpret it.
+        msgRsltCode = RaftMsgResultCode.MESSAGE_RESULT_OK;
+        RaftLog.verbose(
+          `_handleResponseMessages RICREST response without rslt ${rxMsgNum == 0 ? "unnumbered" : "msgNum " + rxMsgNum.toString()} resp ${restStr}`,
         );
       }
 
@@ -726,9 +729,10 @@ export default class RaftMsgHandler {
 
   async sendFileBlock(
     blockContents: Uint8Array,
-    blockStart: number
+    blockStart: number,
+    streamID = 0,
   ): Promise<boolean> {
-    const msgBuf = this.encodeFileStreamBlock(blockContents, blockStart, 0);
+    const msgBuf = this.encodeFileStreamBlock(blockContents, blockStart, streamID);
 
     // // Debug
     // RaftLog.debug(

package/src/RaftTypes.ts

@@ -152,6 +152,7 @@ export type RaftFileStartResp = {
   rslt: string;
   batchMsgSize: number;
   batchAckSize: number;
+  streamID?: number;
 };
 
 export type RaftStreamStartResp = {
@@ -208,6 +209,28 @@ export type RaftProgressCBType = (received: number, total: number) => void;
 
 export type RaftStreamDataProgressCBType = (sent: number, total: number, progress: number) => void;
 
+export type RaftRtStreamDataCBType = (data: Uint8Array, filePos: number, streamID: number) => void;
+
+export type RaftRtStreamOptions = {
+  fileName: string;
+  endpoint: string;
+  onData: RaftRtStreamDataCBType;
+  sendInitialEmptyBlock?: boolean;
+};
+
+export type RaftRtStreamHandle = {
+  streamID: number;
+  maxBlockSize: number;
+  sendBytes: (bytes: Uint8Array) => Promise<boolean>;
+  sendText: (text: string) => Promise<boolean>;
+  close: () => Promise<boolean>;
+};
+
+export type RaftRtStreamStartResp = RaftOKFail & {
+  streamID?: number;
+  maxBlockSize?: number;
+};
+
 export class RaftFileDownloadResult {
   fileData: Uint8Array | null = null;
   downloadedOk = false;

package/src/main.ts

@@ -21,6 +21,7 @@ export { default as RaftFileHandler } from './RaftFileHandler';
 export { default as RaftLog } from './RaftLog';
 export { default as RaftMiniHDLC } from './RaftMiniHDLC';
 export { default as RaftMsgHandler } from './RaftMsgHandler'
+export { default as RaftMicroPythonConsoleClient } from './RaftMicroPythonConsoleClient';
 export { default as RaftStreamHandler } from './RaftStreamHandler';
 export { default as RaftSystemUtils } from './RaftSystemUtils';
 export { default as RaftUtils } from './RaftUtils';