@robotical/raftjs 2.1.2 → 2.1.4

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';