huaweicloud-devkit 1.0.2-next.2 → 1.0.2-next.21

package/plugins/huaweicloud-core/src/ws-exec/hwlink-exec-client.js

@@ -1,3 +1,12 @@
+/*
+ * This file contains code derived from hwlink.
+ *
+ * Source:
+ * https://gitcode.com/huawei-developers/hwlink
+ *
+ * Licensed under the ISC License.
+ */
+
 import {
   DEFAULT_TIMEOUT_MS,
   WebSocketExecError,
@@ -93,9 +102,11 @@ function createHwlinkTerminal(options = {}) {
   }
 
   function handleClose() {
-    settleReady(new WebSocketExecError('hwlink terminal closed before ready', 1, {
-      phase: 'opening',
-    }));
+    settleReady(
+      new WebSocketExecError('hwlink terminal closed before ready', 1, {
+        phase: 'opening',
+      }),
+    );
     if (closed) return;
     closed = true;
     if (onClose) onClose();
@@ -177,10 +188,12 @@ class HwlinkTerminalExecSession {
     });
 
     this.readyTimeout = setTimeout(() => {
-      this.fail(new WebSocketExecError(`hwlink terminal ready timeout after ${this.timeoutMs}ms`, 124, {
-        partialOutput: this.readyBuffer,
-        phase: 'opening',
-      }));
+      this.fail(
+        new WebSocketExecError(`hwlink terminal ready timeout after ${this.timeoutMs}ms`, 124, {
+          partialOutput: this.readyBuffer,
+          phase: 'opening',
+        }),
+      );
     }, this.timeoutMs);
 
     try {
@@ -198,10 +211,12 @@ class HwlinkTerminalExecSession {
     this.term = new HwlinkTerminalChannel(username);
     this.term.onData((data) => this.handleTerminalData(data));
     this.term.onError((error) => {
-      this.fail(new WebSocketExecError(`hwlink terminal error: ${error.message}`, 1, {
-        cause: error,
-        phase: this.state,
-      }));
+      this.fail(
+        new WebSocketExecError(`hwlink terminal error: ${error.message}`, 1, {
+          cause: error,
+          phase: this.state,
+        }),
+      );
     });
     this.term.onReady(() => {
       if (Number.isFinite(this.initialCols) && Number.isFinite(this.initialRows)) {
@@ -211,24 +226,30 @@ class HwlinkTerminalExecSession {
     });
     this.term.onClose(() => {
       if (this.state !== 'closed') {
-        this.fail(new WebSocketExecError('hwlink terminal closed before completion marker', 1, {
-          phase: this.state,
-        }));
+        this.fail(
+          new WebSocketExecError('hwlink terminal closed before completion marker', 1, {
+            phase: this.state,
+          }),
+        );
       }
     });
     this.mux.onClose = () => {
       if (this.state !== 'closed') {
-        this.fail(new WebSocketExecError('hwlink websocket closed before completion marker', 1, {
-          phase: this.state,
-        }));
+        this.fail(
+          new WebSocketExecError('hwlink websocket closed before completion marker', 1, {
+            phase: this.state,
+          }),
+        );
       }
     };
     this.mux.onError = (error) => {
       if (this.state !== 'closed') {
-        this.fail(new WebSocketExecError(`hwlink websocket error: ${error.message}`, 1, {
-          cause: error,
-          phase: this.state,
-        }));
+        this.fail(
+          new WebSocketExecError(`hwlink websocket error: ${error.message}`, 1, {
+            cause: error,
+            phase: this.state,
+          }),
+        );
       }
     };
 
@@ -259,16 +280,20 @@ class HwlinkTerminalExecSession {
     this.pending = null;
 
     if (wasOpening) {
-      this.rejectReady(new WebSocketExecError('hwlink terminal session closed before ready', 1, {
-        phase: 'opening',
-      }));
+      this.rejectReady(
+        new WebSocketExecError('hwlink terminal session closed before ready', 1, {
+          phase: 'opening',
+        }),
+      );
     }
 
     if (pending) {
       clearTimeout(pending.timeout);
-      pending.reject(new WebSocketExecError('hwlink terminal session closed before completion marker', 1, {
-        phase: 'running',
-      }));
+      pending.reject(
+        new WebSocketExecError('hwlink terminal session closed before completion marker', 1, {
+          phase: 'running',
+        }),
+      );
     }
 
     this.term.close();
@@ -328,9 +353,11 @@ class HwlinkTerminalExecSession {
 
   runExec(command, options = {}) {
     if (this.state !== 'ready') {
-      return Promise.reject(new WebSocketExecError('hwlink terminal exec session is not ready', 1, {
-        phase: this.state,
-      }));
+      return Promise.reject(
+        new WebSocketExecError('hwlink terminal exec session is not ready', 1, {
+          phase: this.state,
+        }),
+      );
     }
 
     const shellCommand = normalizeCommand(command);
@@ -347,10 +374,12 @@ class HwlinkTerminalExecSession {
         reject,
         resolve,
         timeout: setTimeout(() => {
-          this.fail(new WebSocketExecError(`hwlink terminal exec timeout after ${timeoutMs}ms`, 124, {
-            partialOutput: this.pending ? this.pending.buffer : '',
-            phase: 'running',
-          }));
+          this.fail(
+            new WebSocketExecError(`hwlink terminal exec timeout after ${timeoutMs}ms`, 124, {
+              partialOutput: this.pending ? this.pending.buffer : '',
+              phase: 'running',
+            }),
+          );
         }, timeoutMs),
       };
 
@@ -363,10 +392,15 @@ class HwlinkTerminalExecSession {
     const pending = this.pending;
     if (!pending) return;
 
-    const doneMatch = pending.buffer.match(pending.markers.donePattern);
-    if (!doneMatch || doneMatch.index === undefined) return;
+    const doneMarker = pending.markers.doneMarker;
+    const markerIndex = pending.buffer.lastIndexOf(doneMarker);
+    if (markerIndex === -1) return;
+
+    const afterMarker = pending.buffer.slice(markerIndex + doneMarker.length);
+    const exitMatch = afterMarker.match(/^(\d+)/);
+    if (!exitMatch) return;
 
-    const rawOutput = pending.buffer.slice(0, doneMatch.index);
+    const rawOutput = pending.buffer.slice(0, markerIndex);
     const stdout = cleanCommandOutput(rawOutput, {
       inputEchoed: this.inputEchoed,
       command: pending.command,
@@ -377,7 +411,7 @@ class HwlinkTerminalExecSession {
     this.pending = null;
     pending.resolve({
       stdout,
-      exitCode: Number(doneMatch[1]),
+      exitCode: Number(exitMatch[1]),
       url: this.url,
       source: this.source,
       username: this.username,

package/plugins/huaweicloud-core/src/ws-exec/hwlink-fair-queue.js

@@ -1,3 +1,12 @@
+/*
+ * This file contains code derived from hwlink.
+ *
+ * Source:
+ * https://gitcode.com/huawei-developers/hwlink
+ *
+ * Licensed under the ISC License.
+ */
+
 const DEFAULT_HIGH_WATERMARK = 8 * 1024 * 1024;
 const DEFAULT_LOW_WATERMARK = 2 * 1024 * 1024;
 
@@ -125,8 +134,4 @@ class FairQueue {
   }
 }
 
-export {
-  DEFAULT_HIGH_WATERMARK,
-  DEFAULT_LOW_WATERMARK,
-  FairQueue,
-};
+export { DEFAULT_HIGH_WATERMARK, DEFAULT_LOW_WATERMARK, FairQueue };

package/plugins/huaweicloud-core/src/ws-exec/hwlink-multiplexer.js

@@ -1,3 +1,12 @@
+/*
+ * This file contains code derived from hwlink.
+ *
+ * Source:
+ * https://gitcode.com/huawei-developers/hwlink
+ *
+ * Licensed under the ISC License.
+ */
+
 import { Buffer } from 'node:buffer';
 
 import { FairQueue } from './hwlink-fair-queue.js';
@@ -81,12 +90,7 @@ function sendBinary(ws, data) {
 
 class HwlinkWebSocketMultiplexer {
   constructor(url, source, options = {}) {
-    const {
-      WebSocketImpl = globalThis.WebSocket,
-      protocol = 'devenv',
-      onFrame,
-      trace = false,
-    } = options;
+    const { WebSocketImpl = globalThis.WebSocket, protocol = 'devenv', onFrame, trace = false } = options;
 
     if (typeof WebSocketImpl !== 'function') {
       throw new Error('global WebSocket is unavailable; use Node.js 22+ or pass WebSocketImpl');
@@ -122,9 +126,7 @@ class HwlinkWebSocketMultiplexer {
     });
 
     addWsListener(this.ws, 'error', (eventOrError) => {
-      const error = eventOrError instanceof Error
-        ? eventOrError
-        : new Error('hwlink websocket error');
+      const error = eventOrError instanceof Error ? eventOrError : new Error('hwlink websocket error');
       this.handleError(error);
     });
 
@@ -219,9 +221,4 @@ class HwlinkWebSocketMultiplexer {
   }
 }
 
-export {
-  HwlinkWebSocketMultiplexer,
-  addWsListener,
-  closeQuietly,
-  eventDataToUint8Array,
-};
+export { HwlinkWebSocketMultiplexer, addWsListener, closeQuietly, eventDataToUint8Array };

package/plugins/huaweicloud-core/src/ws-exec/hwlink-packet.js

@@ -1,3 +1,12 @@
+/*
+ * This file contains code derived from hwlink.
+ *
+ * Source:
+ * https://gitcode.com/huawei-developers/hwlink
+ *
+ * Licensed under the ISC License.
+ */
+
 const FIXED_HEADER_LEN = 20;
 const MAX_SEND_CHUNK_SIZE = 8 * 1024;
 
@@ -42,7 +51,7 @@ function isOpTcpTunnelData(op) {
 }
 
 function isOpFailed(op) {
-  return (op >> 24) !== 0;
+  return op >> 24 !== 0;
 }
 
 function isOpCreateTcpTunnel(op) {
@@ -70,12 +79,7 @@ function hex2(n) {
 }
 
 function operationToString(op) {
-  return [
-    hex2((op >> 24) & 0xff),
-    hex2((op >> 16) & 0xff),
-    hex2((op >> 8) & 0xff),
-    hex2(op & 0xff),
-  ].join(' ');
+  return [hex2((op >> 24) & 0xff), hex2((op >> 16) & 0xff), hex2((op >> 8) & 0xff), hex2(op & 0xff)].join(' ');
 }
 
 function formatPacketOneLine(packet) {
@@ -107,15 +111,7 @@ function toUint8Array(bytes) {
 }
 
 function createPacket(opts) {
-  const {
-    operation,
-    reserve = 0,
-    srcPort = 0,
-    dstPort = 0,
-    identifier = 0,
-    source = 0,
-    payload = null,
-  } = opts;
+  const { operation, reserve = 0, srcPort = 0, dstPort = 0, identifier = 0, source = 0, payload = null } = opts;
 
   const payloadLen = payload ? payload.length : 0;
   const total = FIXED_HEADER_LEN + payloadLen;

package/plugins/huaweicloud-core/src/ws-exec/hwlink-terminal-channel.js

@@ -1,3 +1,12 @@
+/*
+ * This file contains code derived from hwlink.
+ *
+ * Source:
+ * https://gitcode.com/huawei-developers/hwlink
+ *
+ * Licensed under the ISC License.
+ */
+
 import {
   OpCode,
   ReserveSource,
@@ -54,13 +63,15 @@ class HwlinkTerminalChannel {
   onopen() {
     if (this.closed || this.opened) return;
     this.opened = true;
-    this.sendRaw(createPacket({
-      operation: OpCode.OpNewCmdTerminal,
-      reserve: ReserveSource.Web,
-      identifier: this.identifier,
-      source: this.mux ? this.mux.source : 0,
-      payload: encoder.encode(this.username),
-    }));
+    this.sendRaw(
+      createPacket({
+        operation: OpCode.OpNewCmdTerminal,
+        reserve: ReserveSource.Web,
+        identifier: this.identifier,
+        source: this.mux ? this.mux.source : 0,
+        payload: encoder.encode(this.username),
+      }),
+    );
     if (this.onReadyCb) this.onReadyCb();
   }
 
@@ -73,13 +84,15 @@ class HwlinkTerminalChannel {
     }
 
     if (isSubStreamPing(packet.operation)) {
-      this.sendRaw(createPacket({
-        operation: OpCode.OpCmdTerminalData | OpCode.OpSubStreamPong,
-        reserve: ReserveSource.Web,
-        identifier: this.identifier,
-        source: this.mux ? this.mux.source : 0,
-        payload: new Uint8Array(0),
-      }));
+      this.sendRaw(
+        createPacket({
+          operation: OpCode.OpCmdTerminalData | OpCode.OpSubStreamPong,
+          reserve: ReserveSource.Web,
+          identifier: this.identifier,
+          source: this.mux ? this.mux.source : 0,
+          payload: new Uint8Array(0),
+        }),
+      );
       return;
     }
 
@@ -105,13 +118,15 @@ class HwlinkTerminalChannel {
   }
 
   sendTerminalData(payload) {
-    this.sendRaw(createPacket({
-      operation: OpCode.OpCmdTerminalData | OpCode.OpSubStreamPong,
-      reserve: ReserveSource.Web,
-      identifier: this.identifier,
-      source: this.mux ? this.mux.source : 0,
-      payload,
-    }));
+    this.sendRaw(
+      createPacket({
+        operation: OpCode.OpCmdTerminalData | OpCode.OpSubStreamPong,
+        reserve: ReserveSource.Web,
+        identifier: this.identifier,
+        source: this.mux ? this.mux.source : 0,
+        payload,
+      }),
+    );
   }
 
   sendText(text) {
@@ -124,13 +139,15 @@ class HwlinkTerminalChannel {
     const view = new DataView(payload.buffer);
     view.setUint16(0, rows, false);
     view.setUint16(2, cols, false);
-    this.sendRaw(createPacket({
-      operation: OpCode.OpCmdTerminalResize,
-      reserve: ReserveSource.Web,
-      identifier: this.identifier,
-      source: this.mux ? this.mux.source : 0,
-      payload,
-    }));
+    this.sendRaw(
+      createPacket({
+        operation: OpCode.OpCmdTerminalResize,
+        reserve: ReserveSource.Web,
+        identifier: this.identifier,
+        source: this.mux ? this.mux.source : 0,
+        payload,
+      }),
+    );
   }
 
   sendRaw(data) {
@@ -153,6 +170,4 @@ class HwlinkTerminalChannel {
   }
 }
 
-export {
-  HwlinkTerminalChannel,
-};
+export { HwlinkTerminalChannel };

package/plugins/huaweicloud-core/src/ws-exec/hwlink-tunnel-channel.mjs

@@ -0,0 +1,267 @@
+/*
+ * This file contains code derived from hwlink.
+ *
+ * Source:
+ * https://gitcode.com/huawei-developers/hwlink
+ *
+ * Licensed under the ISC License.
+ */
+
+import { createServer } from 'node:net';
+import {
+  OpCode,
+  ReserveSource,
+  FIXED_HEADER_LEN,
+  MAX_SEND_CHUNK_SIZE,
+  createPacket,
+  isOpTunnelSuccess,
+  isOpTcpTunnelData,
+  isOpFailed,
+  isSubStreamPing,
+  nextIdentifier,
+} from './hwlink-packet.js';
+
+const MAX_TUNNEL_PAYLOAD_SIZE = MAX_SEND_CHUNK_SIZE - FIXED_HEADER_LEN;
+
+class HwlinkTunnelChannel {
+  constructor({ localPort = 0, remotePort, onReady, onClose, onError }) {
+    this.localPort = localPort;
+    this.remotePort = remotePort;
+    this.identifier = nextIdentifier();
+    this.mux = null;
+    this.closed = false;
+    this.opened = false;
+
+    this.subConnections = new Map();
+    this.localServer = null;
+    this.nextSubId = 1;
+
+    this.onReadyCb = onReady || null;
+    this.onCloseCb = onClose || null;
+    this.onErrorCb = onError || null;
+
+    this._readyResolve = null;
+    this._readyReject = null;
+    this.ready = new Promise((resolve, reject) => {
+      this._readyResolve = resolve;
+      this._readyReject = reject;
+    });
+  }
+
+  attach(mux) {
+    this.mux = mux;
+    mux.register(this);
+  }
+
+  onopen() {
+    if (this.closed || this.opened) return;
+    this.opened = true;
+    this.startLocalServer();
+  }
+
+  onmessage(packet) {
+    if (this.closed) return;
+
+    if (isOpFailed(packet.operation)) {
+      const subConn = this.subConnections.get(packet.identifier);
+      if (subConn && subConn.socket && !subConn.socket.destroyed) {
+        try {
+          subConn.socket.end();
+        } catch {}
+      }
+      this.subConnections.delete(packet.identifier);
+      this._unregisterSubId(packet.identifier);
+      return;
+    }
+
+    if (isOpTunnelSuccess(packet.operation)) {
+      const subConn = this.subConnections.get(packet.identifier);
+      if (subConn && !subConn.ready) {
+        subConn.ready = true;
+        if (subConn.readyResolve) subConn.readyResolve();
+      }
+      if (packet.identifier === this.identifier && this._readyResolve) {
+        this._readyResolve();
+        this._readyResolve = null;
+        this._readyReject = null;
+      }
+      return;
+    }
+
+    if (isOpTcpTunnelData(packet.operation)) {
+      const subConn = this.subConnections.get(packet.identifier);
+      if (subConn && subConn.socket && !subConn.socket.destroyed) {
+        subConn.socket.write(packet.data);
+      }
+      return;
+    }
+
+    if (isSubStreamPing(packet.operation)) {
+      this.sendRaw(
+        createPacket({
+          operation: OpCode.OpTcpTunnelData | OpCode.OpSubStreamPong,
+          reserve: ReserveSource.Web,
+          identifier: packet.identifier,
+          source: this.mux ? this.mux.source : 0,
+          payload: new Uint8Array(0),
+        }),
+      );
+      return;
+    }
+
+    if (packet.operation === OpCode.OpDisconnect) {
+      const subConn = this.subConnections.get(packet.identifier);
+      if (subConn && subConn.socket && !subConn.socket.destroyed) {
+        subConn.socket.end();
+      }
+      this.subConnections.delete(packet.identifier);
+      this._unregisterSubId(packet.identifier);
+      return;
+    }
+  }
+
+  onerror(error) {
+    if (this.onErrorCb) this.onErrorCb(error);
+    if (this._readyReject) {
+      this._readyReject(error);
+      this._readyResolve = null;
+      this._readyReject = null;
+    }
+  }
+
+  onclose() {
+    this.close();
+  }
+
+  startLocalServer() {
+    this.localServer = createServer((socket) => {
+      this.onIncomingConnection(socket);
+    });
+
+    this.localServer.listen(this.localPort, '127.0.0.1', () => {
+      this.localPort = this.localServer.address().port;
+      if (this.onReadyCb) this.onReadyCb();
+      if (this._readyResolve) {
+        this._readyResolve();
+        this._readyResolve = null;
+        this._readyReject = null;
+      }
+    });
+
+    this.localServer.on('error', (err) => {
+      if (this.onErrorCb) this.onErrorCb(err);
+      if (this._readyReject) {
+        this._readyReject(err);
+        this._readyResolve = null;
+        this._readyReject = null;
+      }
+    });
+  }
+
+  _registerSubId(subId) {
+    if (this.mux && !this.mux.channels.has(subId)) {
+      this.mux.channels.set(subId, this);
+      this.mux.queue.register({ identifier: subId });
+    }
+  }
+
+  _unregisterSubId(subId) {
+    if (this.mux) {
+      this.mux.channels.delete(subId);
+      this.mux.queue.unregister({ identifier: subId });
+    }
+  }
+
+  onIncomingConnection(socket) {
+    const subId = this.nextSubId;
+    this.nextSubId = ((this.nextSubId + 1) & 0xffffffff) >>> 0;
+
+    let readyResolve;
+    const readyPromise = new Promise((resolve) => {
+      readyResolve = resolve;
+    });
+    const subConn = {
+      identifier: subId,
+      socket,
+      ready: false,
+      readyResolve,
+      readyPromise,
+    };
+
+    this.subConnections.set(subId, subConn);
+    this._registerSubId(subId);
+
+    this.sendRaw(
+      createPacket({
+        operation: OpCode.OpCreateTcpTunnel,
+        reserve: ReserveSource.Web,
+        srcPort: this.localPort,
+        dstPort: this.remotePort,
+        identifier: subId,
+        source: this.mux ? this.mux.source : 0,
+        payload: new Uint8Array(0),
+      }),
+    );
+
+    socket.on('data', (data) => {
+      if (this.closed || socket.destroyed) return;
+      for (let offset = 0; offset < data.length; offset += MAX_TUNNEL_PAYLOAD_SIZE) {
+        const payload = data.subarray(offset, offset + MAX_TUNNEL_PAYLOAD_SIZE);
+        this.sendRaw(
+          createPacket({
+            operation: OpCode.OpTcpTunnelData,
+            reserve: ReserveSource.Web,
+            srcPort: this.localPort,
+            dstPort: this.remotePort,
+            identifier: subId,
+            source: this.mux ? this.mux.source : 0,
+            payload,
+          }),
+        );
+      }
+    });
+
+    socket.on('close', () => {
+      this._unregisterSubId(subId);
+      this.subConnections.delete(subId);
+    });
+
+    socket.on('error', () => {
+      this._unregisterSubId(subId);
+      this.subConnections.delete(subId);
+    });
+  }
+
+  destroySubConnection(subConn, error) {
+    if (subConn.socket && !subConn.socket.destroyed) {
+      if (error) subConn.socket.destroy(error);
+      else subConn.socket.destroy();
+    }
+    this._unregisterSubId(subConn.identifier);
+    this.subConnections.delete(subConn.identifier);
+  }
+
+  sendRaw(data) {
+    if (this.mux) this.mux.sendFairly(this, data);
+  }
+
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+
+    for (const subConn of this.subConnections.values()) {
+      this.destroySubConnection(subConn);
+    }
+    this.subConnections.clear();
+
+    if (this.localServer) {
+      this.localServer.close();
+      this.localServer = null;
+    }
+
+    if (this.mux) this.mux.unregister(this);
+    if (this.onCloseCb) this.onCloseCb();
+  }
+}
+
+export { HwlinkTunnelChannel };