diff --git a/gcs/src/components/fla/DownloadLogModal.jsx b/gcs/src/components/fla/DownloadLogModal.jsx
new file mode 100644
index 000000000..6cc7f8eca
--- /dev/null
+++ b/gcs/src/components/fla/DownloadLogModal.jsx
@@ -0,0 +1,188 @@
+import {
+  Button,
+  Group,
+  LoadingOverlay,
+  Modal,
+  Progress,
+  ScrollArea,
+  Text,
+} from "@mantine/core"
+import { useEffect, useState } from "react"
+import { useDispatch, useSelector } from "react-redux"
+import { showErrorNotification } from "../../helpers/notification"
+import {
+  emitListLogFiles,
+  emitReadFile,
+  resetFiles,
+  selectFiles,
+  selectIsReadingFile,
+  selectLoadingListFiles,
+  selectLogPath,
+  selectReadFileProgress,
+} from "../../redux/slices/ftpSlice"
+import { readableBytes } from "./utils"
+
+export default function DownloadLogModal({ opened, onClose }) {
+  const dispatch = useDispatch()
+  const files = useSelector(selectFiles)
+  const loadingListFiles = useSelector(selectLoadingListFiles)
+  const isReadingFile = useSelector(selectIsReadingFile)
+  const readFileProgress = useSelector(selectReadFileProgress)
+  const logPath = useSelector(selectLogPath)
+
+  const [selectedLog, setSelectedLog] = useState(null)
+  const [hasFetched, setHasFetched] = useState(false)
+
+  useEffect(() => {
+    // Fetch log files when modal opens (only once per opening)
+    if (opened && !hasFetched) {
+      dispatch(emitListLogFiles())
+      setHasFetched(true)
+    }
+  }, [opened, hasFetched, dispatch])
+
+  useEffect(() => {
+    // Reset files and fetch state when modal closes
+    if (!opened) {
+      dispatch(resetFiles())
+      setSelectedLog(null)
+      setHasFetched(false)
+    }
+  }, [opened, dispatch])
+
+  async function handleLogClick(log) {
+    // First, ask user where to save the file
+    try {
+      const options = {
+        title: "Save log file",
+        defaultPath: log.name,
+        filters: [
+          { name: "Log Files", extensions: ["bin", "log"] },
+          { name: "All Files", extensions: ["*"] },
+        ],
+      }
+
+      const result = await window.ipcRenderer.invoke(
+        "app:get-save-file-path",
+        options,
+      )
+
+      if (!result.canceled && result.filePath) {
+        // Now download the file with the save path
+        setSelectedLog(log)
+        dispatch(emitReadFile({ path: log.path, savePath: result.filePath }))
+      }
+    } catch (error) {
+      showErrorNotification(`Error selecting save location: ${error.message}`)
+    }
+  }
+
+  function handleRefresh() {
+    dispatch(resetFiles())
+    setHasFetched(false)
+    dispatch(emitListLogFiles())
+    setHasFetched(true)
+  }
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      title="Download Log from Drone"
+      size="lg"
+      centered
+      closeOnEscape={!isReadingFile}
+      closeOnClickOutside={!isReadingFile}
+      withCloseButton={!isReadingFile}
+    >
+      <div className="flex flex-col gap-4">
+        <div className="flex justify-between items-center">
+          <div className="flex flex-col">
+            <Text size="sm" c="dimmed">
+              {files.length > 0
+                ? `Found ${files.length} log file${files.length !== 1 ? "s" : ""}`
+                : loadingListFiles
+                  ? "Searching for logs..."
+                  : "No log files found"}
+            </Text>
+            {logPath && files.length > 0 && (
+              <Text size="xs" c="dimmed">
+                Location: {logPath}
+              </Text>
+            )}
+          </div>
+          <Button
+            size="xs"
+            onClick={handleRefresh}
+            disabled={loadingListFiles || isReadingFile}
+            loading={loadingListFiles}
+          >
+            Refresh
+          </Button>
+        </div>
+
+        {isReadingFile && readFileProgress && (
+          <div className="flex flex-col gap-2 p-3 bg-falcongrey-900/20 rounded">
+            <div className="flex justify-between items-center">
+              <Text size="sm">Downloading: {selectedLog?.name}</Text>
+            </div>
+            <Text size="xs" c="dimmed">
+              {readFileProgress.bytes_downloaded.toLocaleString()} /{" "}
+              {readFileProgress.total_bytes.toLocaleString()} bytes
+            </Text>
+            <Progress
+              value={readFileProgress.percentage}
+              size="lg"
+              animated
+              color="blue"
+            />
+            <Text size="xs" c="dimmed" ta="center">
+              {readFileProgress.percentage}% complete
+            </Text>
+          </div>
+        )}
+
+        <div className="relative">
+          <LoadingOverlay
+            visible={loadingListFiles}
+            zIndex={1000}
+            overlayProps={{ blur: 2 }}
+          />
+
+          <ScrollArea.Autosize mah={400} offsetScrollbars>
+            {files.length > 0 ? (
+              <div className="flex flex-col gap-1">
+                {files.map((log, idx) => (
+                  <div
+                    key={idx}
+                    className={`flex items-center gap-3 p-1 rounded cursor-pointer transition-colors ${
+                      selectedLog?.path === log.path
+                        ? "bg-falcongrey-700/30"
+                        : "hover:bg-falcongrey-600"
+                    } ${isReadingFile ? "opacity-50 pointer-events-none" : ""}`}
+                    onClick={() => handleLogClick(log)}
+                  >
+                    <div className="flex-1">
+                      <Text size="sm">{log.name}</Text>
+                      <Group gap={8}>
+                        <Text size="xs" c="dimmed">
+                          {readableBytes(log.size_b)}
+                        </Text>
+                      </Group>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            ) : (
+              !loadingListFiles && (
+                <div className="text-center py-8 text-gray-400">
+                  <Text size="sm">No log files found</Text>
+                </div>
+              )
+            )}
+          </ScrollArea.Autosize>
+        </div>
+      </div>
+    </Modal>
+  )
+}
diff --git a/gcs/src/components/fla/SelectFlightLog.jsx b/gcs/src/components/fla/SelectFlightLog.jsx
index 2b35458c6..45d853435 100644
--- a/gcs/src/components/fla/SelectFlightLog.jsx
+++ b/gcs/src/components/fla/SelectFlightLog.jsx
@@ -5,14 +5,17 @@ import {
   Progress,
   ScrollArea,
 } from "@mantine/core"
+import { useDisclosure } from "@mantine/hooks"
 import moment from "moment"
 import { useCallback, useEffect, useMemo, useState } from "react"
-import { useDispatch } from "react-redux"
+import { useDispatch, useSelector } from "react-redux"
 import {
   showErrorNotification,
   showSuccessNotification,
 } from "../../helpers/notification.js"
+import { selectConnectedToDrone } from "../../redux/slices/droneConnectionSlice.js"
 import { setFile } from "../../redux/slices/logAnalyserSlice.js"
+import DownloadLogModal from "./DownloadLogModal.jsx"
 import { readableBytes } from "./utils"
 
 /**
@@ -20,9 +23,14 @@ import { readableBytes } from "./utils"
  */
 export default function SelectFlightLog({ getLogSummary }) {
   const dispatch = useDispatch()
+  const connected = useSelector(selectConnectedToDrone)
   const [recentFgcsLogs, setRecentFgcsLogs] = useState(null)
   const [loadingFile, setLoadingFile] = useState(false)
   const [loadingFileProgress, setLoadingFileProgress] = useState(0)
+  const [
+    downloadModalOpened,
+    { open: openDownloadModal, close: closeDownloadModal },
+  ] = useDisclosure(false)
 
   async function getFgcsLogs() {
     setRecentFgcsLogs(await window.ipcRenderer.invoke("fla:get-recent-logs"))
@@ -133,6 +141,11 @@ export default function SelectFlightLog({ getLogSummary }) {
           <Button onClick={selectFile} loading={loadingFile}>
             Analyse a log
           </Button>
+          {connected && (
+            <Button onClick={openDownloadModal} color="blue" variant="filled">
+              Download from Drone
+            </Button>
+          )}
           <Button
             disabled={logsExist}
             color="red"
@@ -172,6 +185,10 @@ export default function SelectFlightLog({ getLogSummary }) {
           color="green"
         />
       )}
+      <DownloadLogModal
+        opened={downloadModalOpened}
+        onClose={closeDownloadModal}
+      />
     </div>
   )
 }
diff --git a/gcs/src/redux/middleware/emitters.js b/gcs/src/redux/middleware/emitters.js
index f4906b3c0..503386bf9 100644
--- a/gcs/src/redux/middleware/emitters.js
+++ b/gcs/src/redux/middleware/emitters.js
@@ -37,6 +37,7 @@ import {
 } from "../slices/droneConnectionSlice"
 import {
   emitListFiles,
+  emitListLogFiles,
   emitReadFile,
   setIsReadingFile,
   setLoadingListFiles,
@@ -389,11 +390,19 @@ export function handleEmitters(socket, store, action) {
         store.dispatch(setLoadingListFiles(true))
       },
     },
+    {
+      emitter: emitListLogFiles,
+      callback: () => {
+        socket.socket.emit("list_log_files")
+        store.dispatch(setLoadingListFiles(true))
+      },
+    },
     {
       emitter: emitReadFile,
       callback: () => {
         socket.socket.emit("read_file", {
           path: action.payload.path,
+          save_path: action.payload.savePath,
         })
         store.dispatch(setIsReadingFile(true))
         store.dispatch(setReadFileProgress(null)) // Reset progress when starting new download
diff --git a/gcs/src/redux/middleware/socketMiddleware.js b/gcs/src/redux/middleware/socketMiddleware.js
index 23ae53fa2..6a58903ec 100644
--- a/gcs/src/redux/middleware/socketMiddleware.js
+++ b/gcs/src/redux/middleware/socketMiddleware.js
@@ -80,6 +80,7 @@ import {
   resetFiles,
   setIsReadingFile,
   setLoadingListFiles,
+  setLogPath,
   setReadFileData,
   setReadFileProgress,
 } from "../slices/ftpSlice.js"
@@ -181,6 +182,7 @@ const ConfigSpecificSocketEvents = Object.freeze({
 
 const FtpSpecificSocketEvents = Object.freeze({
   onListFilesResult: "list_files_result",
+  onListLogFilesResult: "list_log_files_result",
   onReadFileResult: "read_file_result",
   onReadFileProgress: "read_file_progress",
 })
@@ -1099,6 +1101,29 @@ const socketMiddleware = (store) => {
           }
         })
 
+        socket.socket.on(
+          FtpSpecificSocketEvents.onListLogFilesResult,
+          (msg) => {
+            store.dispatch(setLoadingListFiles(false))
+            if (msg.success) {
+              const data = msg.data || {}
+              const files = data.files || []
+              const logPath = data.log_path || null
+
+              store.dispatch(addFiles(files))
+              store.dispatch(setLogPath(logPath))
+
+              if (files.length === 0) {
+                showErrorNotification(
+                  msg.message || "No log files found on drone",
+                )
+              }
+            } else {
+              showErrorNotification(msg.message)
+            }
+          },
+        )
+
         socket.socket.on(FtpSpecificSocketEvents.onReadFileResult, (msg) => {
           if (msg.success) {
             showSuccessNotification(msg.message)
diff --git a/gcs/src/redux/slices/ftpSlice.js b/gcs/src/redux/slices/ftpSlice.js
index cd0d39e54..2f88cdccf 100644
--- a/gcs/src/redux/slices/ftpSlice.js
+++ b/gcs/src/redux/slices/ftpSlice.js
@@ -8,10 +8,12 @@ const ftpSlice = createSlice({
     isReadingFile: false,
     readFileData: null,
     readFileProgress: null, // { bytes_downloaded, total_bytes, percentage }
+    logPath: null, // The discovered log directory path
   },
   reducers: {
     resetFiles: (state) => {
       state.files = []
+      state.logPath = null
     },
     addFiles: (state, action) => {
       // Filter out any files that are "." or ".." or already exist in top level files
@@ -32,11 +34,14 @@ const ftpSlice = createSlice({
           parentPath = "/"
         }
 
-        if (parentPath === "/") {
+        // If this is a top-level file or if there are no existing files in state,
+        // treat it as a top-level file
+        if (parentPath === "/" || state.files.length === 0) {
           // Add top level files since they don't exist already
           state.files.push(file)
           continue
         }
+
         // Try find parentDir recursively
         const parentDir = (function findParentDir(directories, targetPath) {
           for (const dir of directories) {
@@ -59,9 +64,9 @@ const ftpSlice = createSlice({
           }
           parentDir.children.push(file)
         } else {
-          console.warn(
-            `File "${file.name}" with path "${file.path}" could not be added because its parent directory "${parentPath}" is missing in state`,
-          )
+          // If parent directory doesn't exist, treat as top-level file
+          // This happens when we list a specific directory like /logs
+          state.files.push(file)
         }
       }
     },
@@ -77,8 +82,12 @@ const ftpSlice = createSlice({
     setReadFileProgress: (state, action) => {
       state.readFileProgress = action.payload
     },
+    setLogPath: (state, action) => {
+      state.logPath = action.payload
+    },
 
     emitListFiles: () => {},
+    emitListLogFiles: () => {},
     emitReadFile: () => {},
   },
   selectors: {
@@ -87,6 +96,7 @@ const ftpSlice = createSlice({
     selectIsReadingFile: (state) => state.isReadingFile,
     selectReadFileData: (state) => state.readFileData,
     selectReadFileProgress: (state) => state.readFileProgress,
+    selectLogPath: (state) => state.logPath,
   },
 })
 
@@ -97,8 +107,10 @@ export const {
   setIsReadingFile,
   setReadFileData,
   setReadFileProgress,
+  setLogPath,
 
   emitListFiles,
+  emitListLogFiles,
   emitReadFile,
 } = ftpSlice.actions
 
@@ -108,6 +120,7 @@ export const {
   selectIsReadingFile,
   selectReadFileData,
   selectReadFileProgress,
+  selectLogPath,
 } = ftpSlice.selectors
 
 export default ftpSlice
diff --git a/radio/app/controllers/ftpController.py b/radio/app/controllers/ftpController.py
index c950197ae..c0f65dcc6 100644
--- a/radio/app/controllers/ftpController.py
+++ b/radio/app/controllers/ftpController.py
@@ -420,6 +420,9 @@ def listFiles(self, path: str) -> Response:
         """
         # Check if another operation is in progress
         if self.current_op is not None:
+            self.drone.logger.error(
+                f"FTP operation already in progress: {self.current_op}"
+            )
             return {
                 "success": False,
                 "message": f"FTP operation already in progress: {self.current_op}",
@@ -477,27 +480,132 @@ def listFiles(self, path: str) -> Response:
         finally:
             self.current_op = None
 
+    def listLogFiles(self) -> Response:
+        """
+        Intelligently search for and list log files on the drone.
+
+        Checks common log directories in order:
+        1. /logs (standard Linux location)
+        2. /APM/LOGS (ArduPilot uppercase)
+        3. /apm/logs (ArduPilot lowercase)
+
+        Returns:
+            Response: A response object containing log files or error message.
+        """
+        # Check if another operation is in progress
+        if self.current_op is not None:
+            self.drone.logger.error(
+                f"FTP operation already in progress: {self.current_op}"
+            )
+            return {
+                "success": False,
+                "message": f"FTP operation already in progress: {self.current_op}",
+            }
+
+        try:
+            # First, list root directory to see what's available
+            root_result = self.listFiles("/")
+            if not root_result.get("success", False):
+                return {
+                    "success": False,
+                    "message": f"Failed to list root directory: {root_result.get('message', 'Unknown error')}",
+                }
+
+            root_files: list[dict] = root_result.get("data", [])
+            root_dirs = {
+                f["name"].lower(): f["name"]
+                for f in root_files
+                if f.get("is_dir", False)
+            }
+
+            self.drone.logger.info(
+                f"Found directories in root: {list(root_dirs.keys())}"
+            )
+
+            # Determine which log directory exists and use it
+            log_path = None
+            if "logs" in root_dirs:
+                log_path = f"/{root_dirs['logs']}"
+            elif "apm" in root_dirs:
+                # Check if APM directory exists, then check for LOGS subdirectory
+                apm_dir = root_dirs["apm"]
+                apm_result = self.listFiles(f"/{apm_dir}")
+                if apm_result.get("success", False):
+                    apm_files: list[dict] = apm_result.get("data", [])
+                    apm_subdirs = {
+                        f["name"].lower(): f["name"]
+                        for f in apm_files
+                        if f.get("is_dir", False)
+                    }
+                    if "logs" in apm_subdirs:
+                        log_path = f"/{apm_dir}/{apm_subdirs['logs']}"
+
+            if log_path is None:
+                return {
+                    "success": True,
+                    "message": "No log directory found on drone",
+                    "data": {"files": [], "log_path": None},
+                }
+
+            self.drone.logger.info(f"Using log directory: {log_path}")
+
+            # List files in the log directory
+            logs_result = self.listFiles(log_path)
+            if not logs_result.get("success", False):
+                return {
+                    "success": False,
+                    "message": f"Failed to list log directory {log_path}: {logs_result.get('message', 'Unknown error')}",
+                }
+
+            log_files: list[dict] = logs_result.get("data", [])
+
+            filtered_logs = [f for f in log_files if not f.get("is_dir", False)]
+
+            self.drone.logger.info(
+                f"Found {len(filtered_logs)} log files in {log_path}"
+            )
+
+            return {
+                "success": True,
+                "message": f"Found {len(filtered_logs)} log files",
+                "data": {"files": filtered_logs, "log_path": log_path},
+            }
+
+        except Exception as e:
+            self.drone.logger.error("Error listing log files", exc_info=True)
+            return {
+                "success": False,
+                "message": f"Error listing log files: {e}",
+            }
+        finally:
+            self.current_op = None
+
     def readFile(
         self,
         path: str,
+        save_path: Optional[str] = None,
         size: Optional[int] = None,
         offset: int = 0,
         progress_callback=None,
     ) -> Response:
         """
-        Read/download a file from the drone using MAVFTP.
+        Read/download a file from the drone using MAVFTP and optionally save it to disk.
 
         Args:
-            path (str): The file path to read.
+            path (str): The remote file path to read.
+            save_path (Optional[str]): Local file path where to save the file. If None, returns data in response.
             size (Optional[int]): Number of bytes to read. If None, reads entire file.
             offset (int): Offset in bytes to start reading from.
             progress_callback: Optional callback function called with (bytes_downloaded, total_bytes, percentage)
 
         Returns:
-            Response: A response object containing the file data or error message.
+            Response: A response object containing success status and file info (not the data if saved to disk).
         """
         # Check if another operation is in progress
         if self.current_op is not None:
+            self.drone.logger.error(
+                f"FTP operation already in progress: {self.current_op}"
+            )
             return {
                 "success": False,
                 "message": f"FTP operation already in progress: {self.current_op}",
@@ -562,15 +670,44 @@ def readFile(
                 # Return entire file
                 result_data = all_data
 
-            self.drone.logger.info(
-                f"Successfully read {len(result_data)} bytes from file: {path}"
-            )
+            file_name = path.split("/")[-1]
 
-            return {
-                "success": True,
-                "message": "File read successfully",
-                "data": {"file_data": result_data, "file_name": path.split("/")[-1]},
-            }
+            # Save to disk if save_path is provided
+            if save_path:
+                try:
+                    with open(save_path, "wb") as f:
+                        f.write(result_data)
+
+                    self.drone.logger.info(
+                        f"Successfully saved {len(result_data)} bytes to: {save_path}"
+                    )
+
+                    return {
+                        "success": True,
+                        "message": f"File saved successfully to {save_path}",
+                        "data": {
+                            "file_name": file_name,
+                            "file_data": None,
+                            "save_path": save_path,
+                        },
+                    }
+                except Exception as e:
+                    self.drone.logger.error(f"Error saving file to {save_path}: {e}")
+                    return {
+                        "success": False,
+                        "message": f"Failed to save file: {str(e)}",
+                    }
+            else:
+                # Return data in response (for backward compatibility)
+                self.drone.logger.info(
+                    f"Successfully read {len(result_data)} bytes from file: {path}"
+                )
+
+                return {
+                    "success": True,
+                    "message": "File read successfully",
+                    "data": {"file_data": result_data, "file_name": file_name},
+                }
         finally:
             self.progress_callback = None
             self.current_op = None
diff --git a/radio/app/endpoints/ftp.py b/radio/app/endpoints/ftp.py
index 0beb73bc4..338dd0dab 100644
--- a/radio/app/endpoints/ftp.py
+++ b/radio/app/endpoints/ftp.py
@@ -1,7 +1,7 @@
-from typing_extensions import TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 import app.droneStatus as droneStatus
-from app import logger, socketio
+from app import socketio
 from app.utils import notConnectedError
 
 
@@ -11,6 +11,7 @@ class ListFilesType(TypedDict):
 
 class ReadFileType(TypedDict):
     path: str
+    save_path: NotRequired[str]
 
 
 @socketio.on("list_files")
@@ -21,14 +22,6 @@ def listFiles(data: ListFilesType) -> None:
     Args:
         data: The data from the client, this contains "path" which is the directory path to list files from
     """
-    if droneStatus.state is None or "config" not in droneStatus.state:
-        socketio.emit(
-            "params_error",
-            {"message": "You must be on the config screen to access FTP operations"},
-        )
-        logger.debug(f"Current state: {droneStatus.state}")
-        return
-
     if not droneStatus.drone:
         return notConnectedError(action="list files")
 
@@ -39,26 +32,36 @@ def listFiles(data: ListFilesType) -> None:
     socketio.emit("list_files_result", result)
 
 
+@socketio.on("list_log_files")
+def listLogFiles() -> None:
+    """
+    Intelligently search for and list log files on the drone.
+    Automatically finds the correct log directory (/logs, /APM/LOGS, etc.)
+    """
+    if not droneStatus.drone:
+        return notConnectedError(action="list log files")
+
+    result = droneStatus.drone.ftpController.listLogFiles()
+
+    socketio.emit("list_log_files_result", result)
+
+
 @socketio.on("read_file")
 def readFile(data: ReadFileType) -> None:
     """
-    Read/download a file from the drone's FTP server
+    Read/download a file from the drone's FTP server and save it locally
 
     Args:
-        data: The data from the client, this contains "path" which is the file path to read/download
+        data: The data from the client, contains:
+            - "path": The remote file path to read/download
+            - "save_path": The local file path where to save the file
     """
-    if droneStatus.state is None or "config" not in droneStatus.state:
-        socketio.emit(
-            "params_error",
-            {"message": "You must be on the config screen to access FTP operations"},
-        )
-        logger.debug(f"Current state: {droneStatus.state}")
-        return
-
     if not droneStatus.drone:
         return notConnectedError(action="read file")
 
     path = data.get("path", None)
+    save_path = data.get("save_path", None)
+
     if path is None:
         socketio.emit(
             "read_file_result", {"success": False, "message": "Missing file path"}
@@ -76,13 +79,14 @@ def progress_callback(bytes_downloaded, total_bytes, percentage):
         )
 
     result = droneStatus.drone.ftpController.readFile(
-        path, progress_callback=progress_callback
+        path, save_path=save_path, progress_callback=progress_callback
     )
 
-    # Convert bytes to list for SocketIO serialization
+    # Convert bytes to list for SocketIO serialization if file_data is present
     if result.get("success") and "data" in result:
         data_dict = result["data"]
         if isinstance(data_dict, dict) and "file_data" in data_dict:
-            data_dict["file_data"] = list(data_dict["file_data"])
+            if data_dict["file_data"] is not None:
+                data_dict["file_data"] = list(data_dict["file_data"])
 
     socketio.emit("read_file_result", result)
diff --git a/radio/tests/test_ftp.py b/radio/tests/test_ftp.py
index 0cc907837..56bd12d28 100644
--- a/radio/tests/test_ftp.py
+++ b/radio/tests/test_ftp.py
@@ -11,18 +11,6 @@
 )
 
 
-@falcon_test(pass_drone_status=True)
-def test_listFiles_wrongState_failure(socketio_client: SocketIOTestClient, droneStatus):
-    droneStatus.state = "dashboard"
-    socketio_client.emit("list_files", {})
-    socketio_result = socketio_client.get_received()[0]
-
-    assert socketio_result["name"] == "params_error"
-    assert socketio_result["args"][0] == {
-        "message": "You must be on the config screen to access FTP operations"
-    }
-
-
 @falcon_test(pass_drone_status=True)
 def test_listFiles_noPath_success(socketio_client: SocketIOTestClient, droneStatus):
     droneStatus.state = "config"
@@ -142,18 +130,6 @@ def test_listFiles_noDroneConnection_failure(
         }
 
 
-@falcon_test(pass_drone_status=True)
-def test_readFile_wrongState_failure(socketio_client: SocketIOTestClient, droneStatus):
-    droneStatus.state = "dashboard"
-    socketio_client.emit("read_file", {"path": "/@ROMFS/locations.txt"})
-    socketio_result = socketio_client.get_received()[0]
-
-    assert socketio_result["name"] == "params_error"
-    assert socketio_result["args"][0] == {
-        "message": "You must be on the config screen to access FTP operations"
-    }
-
-
 @falcon_test(pass_drone_status=True)
 def test_readFile_missingPath_failure(socketio_client: SocketIOTestClient, droneStatus):
     droneStatus.state = "config"
@@ -252,3 +228,19 @@ def test_readFile_noDroneConnection_failure(
         assert socketio_result["args"][0] == {
             "message": "Must be connected to the drone to read file."
         }
+
+
+@falcon_test(pass_drone_status=True)
+def test_listLogFiles_noDroneConnection_failure(
+    socketio_client: SocketIOTestClient, droneStatus
+):
+    droneStatus.state = "config"
+
+    with NoDrone():
+        socketio_client.emit("list_log_files")
+        socketio_result = socketio_client.get_received()[0]
+
+        assert socketio_result["name"] == "connection_error"
+        assert socketio_result["args"][0] == {
+            "message": "Must be connected to the drone to list log files."
+        }