Attempt a workaround for the bad response issue

See microbit-foundation/python-editor-v3#89

Ultimately this needs a fix in DAPLink to clear the queue on reset but that
won't have much impact on existing devices.

Author: microbit-matt-hillsdon

lib/usb-device-wrapper.ts

@@ -96,7 +96,7 @@ export class DAPWrapper {
       this.initialConnectionComplete = true;
     }
 
-    await this.daplink.connect();
+    await this.connectWithRetry();
     await this.cortexM.connect();
 
     this.logging.event({
@@ -154,6 +154,83 @@ export class DAPWrapper {
     throw lastError;
   }
 
+  /**
+   * Drain any stale responses from the USB buffer.
+   * Sends a known command (DAP_INFO) and keeps reading until we get the
+   * matching response. This recovers from the state where a previous session
+   * was closed mid-serial-read, leaving stale responses in the device's
+   * USB buffer that break subsequent connections.
+   *
+   * See: https://github.com/microbit-foundation/python-editor-v3/issues/89
+   */
+  private async drainStaleResponses(): Promise<void> {
+    // DAPLink's DAP_PACKET_COUNT is 5-8 for micro:bit variants.
+    // In practice, only 1-2 stale responses are typical (from interrupted serial read).
+    // Use a value slightly above the max buffer size as a safety margin.
+    const maxAttempts = 10;
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      // DAP_INFO is a safe, read-only command that always succeeds
+      const packet = [DapCmd.DAP_INFO, 0x01];
+      await this.transport.write(Uint8Array.from(packet).buffer);
+
+      const response = await this.transport.read();
+      const responseBytes = new Uint8Array(response.buffer);
+
+      if (responseBytes[0] === DapCmd.DAP_INFO) {
+        this.logging.log("USB buffer drain: synchronized");
+        return;
+      }
+      this.logging.log(
+        `USB buffer drain: discarded stale response 0x${responseBytes[0].toString(16)}, expected 0x${DapCmd.DAP_INFO.toString(16)}`,
+      );
+    }
+
+    this.logging.log(
+      "USB buffer drain: warning - could not fully synchronize after max attempts",
+    );
+  }
+
+  /**
+   * Connect to daplink with retry logic for stale response recovery.
+   * If a "Bad response" error occurs (indicating stale USB data from a
+   * previous session), this method will drain the stale responses and retry.
+   */
+  private async connectWithRetry(maxRetries = 3): Promise<void> {
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        if (attempt > 0) {
+          this.logging.log(
+            `Connection retry attempt ${attempt + 1}/${maxRetries}`,
+          );
+          await this.drainStaleResponses();
+        }
+
+        await this.daplink.connect();
+        return;
+      } catch (e) {
+        // https://github.com/ARMmbed/dapjs/blob/master/src/proxy/cmsis-dap.ts#L178
+        if (e instanceof Error && /^Bad response for /.test(e.message)) {
+          lastError = e;
+          this.logging.log(`Bad response error during connect: ${e.message}`);
+
+          try {
+            await this.transport.close();
+          } catch {
+            // Ignore close errors
+          }
+          await this.transport.open();
+          continue;
+        }
+        throw e;
+      }
+    }
+
+    throw lastError || new Error("Connection failed after retries");
+  }
+
   async startSerial(listener: (data: string) => void): Promise<void> {
     const currentBaud = await this.daplink.getSerialBaudrate();
     if (currentBaud !== 115200) {