add onDeviceLostCallback to recover lost device

Author: brianignacio5

examples/typescript/src/index.ts

@@ -49,6 +49,7 @@ const term = new Terminal({ cols: 120, rows: 40 });
 term.open(terminal);
 
 let device = null;
+let deviceInfo = null;
 let transport: Transport;
 let chip: string = null;
 let esploader: ESPLoader;
@@ -105,6 +106,7 @@ connectButton.onclick = async () => {
   try {
     if (device === null) {
       device = await serialLib.requestPort({});
+      deviceInfo = device.getInfo();
       transport = new Transport(device, true);
     }
     const flashOptions = {
@@ -228,6 +230,7 @@ function removeRow(row: HTMLTableRowElement) {
  */
 function cleanUp() {
   device = null;
+  deviceInfo = null;
   transport = null;
   chip = null;
   initializePartitionTable();
@@ -461,11 +464,50 @@ disconnectButton.onclick = async () => {
 };
 
 let isConsoleClosed = false;
+let isReconnecting = false;
+
+const sleep = async (ms: number) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
 consoleStartButton.onclick = async () => {
   if (device === null) {
     device = await serialLib.requestPort({});
     transport = new Transport(device, true);
+    deviceInfo = device.getInfo();
+
+    // Set up device lost callback
+    transport.setDeviceLostCallback(async () => {
+      if (!isConsoleClosed && !isReconnecting) {
+        term.writeln("\n[DEVICE LOST] Device disconnected. Click 'Reconnect' to restore connection...");
+        await sleep(1000);
+        isReconnecting = true;
+        term.writeln("\n[RECONNECT] Attempting to reconnect...");
+        if (serialLib && serialLib.getPorts) {
+          const ports = await serialLib.getPorts();
+          if (ports.length > 0) {
+            const newDevice = ports.find(
+              (port) =>
+                port.getInfo().usbVendorId === deviceInfo.usbVendorId &&
+                port.getInfo().usbProductId === deviceInfo.usbProductId,
+            );
+            device = newDevice;
+            transport.updateDevice(device);
+            term.writeln("[RECONNECT] Found previously authorized device, connecting...");
+            await transport.connect(parseInt(consoleBaudrates.value));
+            term.writeln("[RECONNECT] Successfully reconnected!");
+            consoleStopButton.style.display = "initial";
+            resetButton.style.display = "initial";
+            isReconnecting = false;
+
+            startConsoleReading();
+            return;
+          }
+        }
+      }
+    });
   }
+
   lblConsoleFor.style.display = "block";
   lblConsoleBaudrate.style.display = "none";
   consoleBaudrates.style.display = "none";
@@ -476,21 +518,45 @@ consoleStartButton.onclick = async () => {
 
   await transport.connect(parseInt(consoleBaudrates.value));
   isConsoleClosed = false;
+  isReconnecting = false;
+
+  startConsoleReading();
+};
+
+/**
+ * Start the console reading loop
+ */
+async function startConsoleReading() {
+  if (isConsoleClosed || !transport) return;
 
-  while (true && !isConsoleClosed) {
+  try {
     const readLoop = transport.rawRead();
-    const { value, done } = await readLoop.next();
 
-    if (done || !value) {
-      break;
+    while (true && !isConsoleClosed) {
+      const { value, done } = await readLoop.next();
+
+      if (done || !value) {
+        break;
+      }
+
+      if (value) {
+        term.write(value);
+      }
+    }
+  } catch (error) {
+    if (!isConsoleClosed) {
+      term.writeln(`\n[CONSOLE ERROR] ${error instanceof Error ? error.message : String(error)}`);
     }
-    term.write(value);
   }
-  console.log("quitting console");
-};
+
+  if (!isConsoleClosed) {
+    term.writeln("\n[CONSOLE] Connection lost, waiting for reconnection...");
+  }
+}
 
 consoleStopButton.onclick = async () => {
   isConsoleClosed = true;
+  isReconnecting = false;
   if (transport) {
     await transport.disconnect();
     await transport.waitForUnlock(1500);

src/webserial.ts

@@ -63,11 +63,30 @@ class Transport {
   private lastTraceTime = Date.now();
   private reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
   private buffer: Uint8Array = new Uint8Array(0);
+  private onDeviceLostCallback: (() => void) | null = null;
 
   constructor(public device: SerialPort, public tracing = false, enableSlipReader = true) {
     this.slipReaderEnabled = enableSlipReader;
   }
 
+  /**
+   * Set callback for when device is lost
+   * @param callback Function to call when device is lost
+   */
+  setDeviceLostCallback(callback: (() => void) | null) {
+    this.onDeviceLostCallback = callback;
+  }
+
+
+  /**
+   * Update the device reference (used when re-selecting device after reset)
+   * @param newDevice New SerialPort device
+   */
+  updateDevice(newDevice: SerialPort) {
+    this.device = newDevice;
+    this.trace("Device reference updated");
+  }
+
   /**
    * Request the serial device vendor ID and Product ID as string.
    * @returns {string} Return the device VendorID and ProductID from SerialPortInfo as formatted string.
@@ -388,6 +407,14 @@ class Transport {
       }
     } catch (error) {
       console.error("Error reading from serial port:", error);
+      
+      // Check if it's a NetworkError indicating device loss
+      if (error instanceof Error && error.name === 'NetworkError' && error.message.includes('device has been lost')) {
+        this.trace("Device lost detected (NetworkError)");
+        if (this.onDeviceLostCallback) {
+          this.onDeviceLostCallback();
+        }
+      }
     } finally {
       this.buffer = new Uint8Array(0);
     }