wip

Author: Williangalvani

core/frontend/src/components/autopilot/FirmwareManager.vue

@@ -215,6 +215,7 @@
           />
           <div
             v-if="install_logs.length > 0"
+            ref="installLogsContainer"
             class="install-logs pa-2"
           >
             <div
@@ -417,6 +418,14 @@ export default Vue.extend({
         this.chosen_platform = chosen_platform
       }
     },
+    install_logs(): void {
+      this.$nextTick(() => {
+        const container = this.$refs.installLogsContainer as HTMLElement | undefined
+        if (container) {
+          container.scrollTop = container.scrollHeight
+        }
+      })
+    },
   },
   mounted(): void {
     if (this.only_bootloader_boards_available) {
@@ -535,7 +544,7 @@ export default Vue.extend({
                 const log = JSON.parse(line)
 
                 // Check if backend sent "done" signal to close connection
-                if (log.stream === 'done') {
+                if (log.stream === 'done' || log.stream.includes("Started autopilot")) {
                   // Close the progress dialog immediately
                   this.install_status = InstallStatus.Succeeded
                   this.install_result_message = 'Installation completed'

core/services/ardupilot_manager/firmware/FirmwareUpload.py

@@ -9,6 +9,64 @@
 from exceptions import FirmwareUploadFail, InvalidUploadTool, UploadToolNotFound
 
 
+class StreamReader:
+    """Reads a stream byte-by-byte, treating both \\n and \\r as line delimiters.
+
+    Automatically sends buffered data after 1 second of inactivity.
+    """
+
+    def __init__(
+        self,
+        stream: asyncio.StreamReader,
+        stream_name: str,
+        output_callback: Optional[Callable[[str, str], Awaitable[None]]] = None,
+        timeout: float = 1.0,
+    ) -> None:
+        self.stream = stream
+        self.stream_name = stream_name
+        self.output_callback = output_callback
+        self.timeout = timeout
+        self.buffer = b""
+        self.lines: list[str] = []
+
+    async def _send_line(self, line: str) -> None:
+        """Send a decoded line through the callback and logger."""
+        if line:
+            logger.debug(f"[{self.stream_name}] {line}")
+            self.lines.append(line)
+            if self.output_callback:
+                await self.output_callback(self.stream_name, line)
+
+    async def _flush_buffer(self) -> None:
+        """Flush the current buffer and send as a line."""
+        if self.buffer:
+            decoded_line = self.buffer.decode().rstrip("\r\n")
+            await self._send_line(decoded_line)
+            self.buffer = b""
+
+    async def read_all(self) -> None:
+        """Read all data from the stream until it closes."""
+        while True:
+            try:
+                # Try to read one byte with timeout
+                chunk = await asyncio.wait_for(self.stream.read(1), timeout=self.timeout)
+                if not chunk:
+                    # End of stream - send any remaining buffer
+                    await self._flush_buffer()
+                    break
+
+                self.buffer += chunk
+
+                # Check if we hit a line delimiter (\n or \r)
+                if chunk in (b"\n", b"\r"):
+                    decoded_line = self.buffer.decode().rstrip("\r\n")
+                    await self._send_line(decoded_line)
+                    self.buffer = b""
+            except asyncio.TimeoutError:
+                # Timeout passed without new data - send buffer if non-empty
+                await self._flush_buffer()
+
+
 class FirmwareUploader:
     def __init__(self) -> None:
         self._autopilot_port: pathlib.Path = pathlib.Path("/dev/autopilot")
@@ -60,30 +118,16 @@ async def upload(
             stderr=asyncio.subprocess.PIPE,
             shell=True,
         )
-        errors = []
+        stdout_reader = StreamReader(process.stdout, "stdout", output_callback) if process.stdout else None
+        stderr_reader = StreamReader(process.stderr, "stderr", output_callback) if process.stderr else None
 
         async def read_stdout() -> None:
-            if process.stdout:
-                while True:
-                    line = await process.stdout.readline()
-                    if not line:
-                        break
-                    decoded_line = line.decode().rstrip("\n")
-                    logger.debug(f"[stdout] {decoded_line}")
-                    if output_callback:
-                        await output_callback("stdout", decoded_line)
+            if stdout_reader:
+                await stdout_reader.read_all()
 
         async def read_stderr() -> None:
-            if process.stderr:
-                while True:
-                    line = await process.stderr.readline()
-                    if not line:
-                        break
-                    decoded_line = line.decode().rstrip("\n")
-                    logger.debug(f"[stderr] {decoded_line}")
-                    errors.append(decoded_line)
-                    if output_callback:
-                        await output_callback("stderr", decoded_line)
+            if stderr_reader:
+                await stderr_reader.read_all()
 
         try:
             # Run both stream readers and process wait concurrently with a single timeout
@@ -98,6 +142,7 @@ async def read_stderr() -> None:
             raise FirmwareUploadFail("Unable to upload firmware to board.") from error
         finally:
             return_code = process.returncode
+            errors = stderr_reader.lines if stderr_reader else []
             if errors and return_code != 0:
                 raise FirmwareUploadFail(f"Upload process returned errors: {errors} return code: {return_code}")
             if return_code != 0: