mpytool 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

mpytool/mpytool.py

@@ -1,14 +1,17 @@
 """MicroPython tool"""
 
-import os as _os
-import sys as _sys
 import argparse as _argparse
+import fnmatch as _fnmatch
 import hashlib as _hashlib
+import importlib.metadata as _metadata
+import os as _os
+import sys as _sys
+import time as _time
+
 import mpytool as _mpytool
 import mpytool.terminal as _terminal
 import mpytool.utils as _utils
 from mpytool.logger import SimpleColorLogger
-import importlib.metadata as _metadata
 
 try:
     _about = _metadata.metadata("mpytool")
@@ -26,24 +29,41 @@ class MpyTool():
     TEE = '├─ '
     LAST = '└─ '
 
-    def __init__(self, conn, log=None, verbose=None, exclude_dirs=None, force=False):
+    def __init__(
+            self, conn, log=None, verbose=None, exclude_dirs=None,
+            force=False, compress=None, chunk_size=None):
         self._conn = conn
         self._log = log if log is not None else SimpleColorLogger()
         self._verbose_out = verbose  # None = no verbose output (API mode)
-        self._exclude_dirs = {'__pycache__', '.git', '.svn'}
+        self._exclude_dirs = {'.*', '*.pyc'}
         if exclude_dirs:
             self._exclude_dirs.update(exclude_dirs)
-        self._mpy = _mpytool.Mpy(conn, log=self._log)
-        self._force = force  # Skip unchanged file check
-        # Progress tracking
+        self._mpy = _mpytool.Mpy(conn, log=self._log, chunk_size=chunk_size)
+        self._force = force
+        self._compress = compress
         self._progress_total_files = 0
         self._progress_current_file = 0
         self._progress_src = ''
         self._progress_dst = ''
         self._progress_max_src_len = 0
+        self._progress_max_dst_len = 0
         self._is_debug = getattr(self._log, '_loglevel', 1) >= 4
         self._batch_mode = False
         self._skipped_files = 0
+        self._stats_total_bytes = 0
+        self._stats_transferred_bytes = 0
+        self._stats_wire_bytes = 0  # Actual bytes sent over wire (with encoding)
+        self._stats_transferred_files = 0
+        self._stats_start_time = None
+        # Remote file info cache for batch operations
+        self._remote_file_cache = {}  # {path: (size, hash) or None}
+
+    def _is_excluded(self, name):
+        """Check if name matches any exclude pattern (supports wildcards)"""
+        for pattern in self._exclude_dirs:
+            if _fnmatch.fnmatch(name, pattern):
+                return True
+        return False
 
     @property
     def _is_tty(self):
@@ -61,6 +81,14 @@ class MpyTool():
         if self._verbose_out is not None:
             self._verbose_out.verbose(msg, level, color, end, overwrite)
 
+    def print_transfer_info(self):
+        """Print transfer settings (chunk size and compression)"""
+        chunk = self._mpy._detect_chunk_size()
+        chunk_str = f"{chunk // 1024}K" if chunk >= 1024 else str(chunk)
+        compress = self._mpy._detect_deflate() if self._compress is None else self._compress
+        compress_str = "on" if compress else "off"
+        self.verbose(f"COPY (chunk: {chunk_str}, compress: {compress_str})", 1)
+
     @staticmethod
     def _format_local_path(path):
         """Format local path: relative from CWD, absolute if > 2 levels up"""
@@ -81,16 +109,36 @@ class MpyTool():
             # On Windows, relpath fails for different drives
             return _os.path.abspath(path)
 
-    def _format_progress_line(self, percent, total):
-        """Format progress line: [2/5]  23% 24.1KB source -> dest"""
-        size_str = self.format_size(total).replace(' ', '')
-        if self._progress_total_files > 1:
-            prefix = f"[{self._progress_current_file}/{self._progress_total_files}]"
-        else:
-            prefix = ""
-        # Pad source to align ->
-        src_width = max(len(self._progress_src), self._progress_max_src_len)
-        return f"{prefix:>7} {percent:3d}% {size_str:>7} {self._progress_src:<{src_width}} -> {self._progress_dst}"
+    # Encoding info strings for alignment: (base64), (compressed), (base64, compressed), (unchanged)
+    _ENC_WIDTH = 22  # Length of longest: "  (base64, compressed)"
+
+    def _format_encoding_info(self, encodings, pad=False):
+        """Format encoding info: (base64), (compressed), (base64, compressed)"""
+        if not encodings or encodings == {'raw'}:
+            return " " * self._ENC_WIDTH if pad else ""
+        types = sorted(e for e in encodings if e != 'raw')
+        if not types:
+            return " " * self._ENC_WIDTH if pad else ""
+        info = f"  ({', '.join(types)})"
+        if pad:
+            return f"{info:<{self._ENC_WIDTH}}"
+        return info
+
+    def _format_line(self, status, total, encodings=None):
+        """Format progress/skip line: [2/5] 100% 24.1K source -> dest (base64)"""
+        size_str = self.format_size(total)
+        multi = self._progress_total_files > 1
+        prefix = f"[{self._progress_current_file}/{self._progress_total_files}]" if multi else ""
+        src_w = max(len(self._progress_src), self._progress_max_src_len)
+        dst_w = max(len(self._progress_dst), self._progress_max_dst_len)
+        enc = self._format_encoding_info(encodings, pad=multi) if encodings else (" " * self._ENC_WIDTH if multi else "")
+        return f"{prefix:>7} {status} {size_str:>5} {self._progress_src:<{src_w}} -> {self._progress_dst:<{dst_w}}{enc}"
+
+    def _format_progress_line(self, percent, total, encodings=None):
+        return self._format_line(f"{percent:3d}%", total, encodings)
+
+    def _format_skip_line(self, total):
+        return self._format_line("skip", total, {'unchanged'})
 
     def _progress_callback(self, transferred, total):
         """Callback for file transfer progress"""
@@ -103,14 +151,13 @@ class MpyTool():
             # Normal mode: overwrite line
             self.verbose(line, color='cyan', end='', overwrite=True)
 
-    def _progress_complete(self, total):
+    def _progress_complete(self, total, encodings=None):
         """Mark current file as complete"""
-        line = self._format_progress_line(100, total)
+        line = self._format_progress_line(100, total, encodings)
         if self._is_debug:
             # Already printed with newline in callback
             pass
         else:
-            # Print final line with newline
             self.verbose(line, color='cyan', overwrite=True)
 
     def _set_progress_info(self, src, dst, is_src_remote, is_dst_remote):
@@ -123,16 +170,77 @@ class MpyTool():
             self._progress_dst = ':' + dst
         else:
             self._progress_dst = self._format_local_path(dst)
+        if len(self._progress_dst) > self._progress_max_dst_len:
+            self._progress_max_dst_len = len(self._progress_dst)
 
-    def _count_local_files(self, path):
-        """Count files in local directory (excluding excluded dirs)"""
+    def _collect_local_paths(self, path):
+        """Collect all local file paths (formatted for display)"""
         if _os.path.isfile(path):
-            return 1
-        count = 0
-        for _, dirs, files in _os.walk(path, topdown=True):
-            dirs[:] = [d for d in dirs if d not in self._exclude_dirs]
-            count += len(files)
-        return count
+            return [self._format_local_path(path)]
+        paths = []
+        for root, dirs, files in _os.walk(path, topdown=True):
+            dirs[:] = [d for d in dirs if not self._is_excluded(d)]
+            files = [f for f in files if not self._is_excluded(f)]
+            paths.extend(self._format_local_path(_os.path.join(root, f)) for f in files)
+        return paths
+
+    def _prefetch_remote_info(self, dst_files):
+        """Prefetch remote file info (size and hash) for multiple files
+
+        Arguments:
+            dst_files: dict {remote_path: local_size} - sizes used to skip hash if mismatch
+
+        Uses batch call to reduce round-trips. Results are cached in _remote_file_cache.
+        """
+        if self._force or not dst_files:
+            return
+        files_to_fetch = {p: s for p, s in dst_files.items() if p not in self._remote_file_cache}
+        if not files_to_fetch:
+            return
+        self.verbose(f"Checking {len(files_to_fetch)} files...", 2)
+        result = self._mpy.fileinfo(files_to_fetch)
+        if result is None:
+            # hashlib not available - mark all as needing update
+            for path in files_to_fetch:
+                self._remote_file_cache[path] = None
+        else:
+            self._remote_file_cache.update(result)
+
+    def _collect_dst_files(self, src_path, dst_path, add_src_basename=True):
+        """Collect destination paths and local sizes for a local->remote copy operation
+
+        Arguments:
+            src_path: local source path (file or directory)
+            dst_path: remote destination base path
+            add_src_basename: if True, add source basename to dst_path (matching _put_dir behavior)
+
+        Returns:
+            dict {remote_path: local_file_size}
+        """
+        files = {}
+        if _os.path.isfile(src_path):
+            # For files, add basename if dst_path ends with /
+            basename = _os.path.basename(src_path)
+            if basename and not _os.path.basename(dst_path):
+                dst_path = _os.path.join(dst_path, basename)
+            files[dst_path] = _os.path.getsize(src_path)
+        elif _os.path.isdir(src_path):
+            # For directories, mimic _put_dir behavior
+            if add_src_basename:
+                basename = _os.path.basename(_os.path.abspath(src_path))
+                if basename:
+                    dst_path = _os.path.join(dst_path, basename)
+            for root, dirs, filenames in _os.walk(src_path, topdown=True):
+                dirs[:] = [d for d in dirs if not self._is_excluded(d)]
+                filenames = [f for f in filenames if not self._is_excluded(f)]
+                rel_path = _os.path.relpath(root, src_path)
+                if rel_path == '.':
+                    rel_path = ''
+                for file_name in filenames:
+                    spath = _os.path.join(root, file_name)
+                    dpath = _os.path.join(dst_path, rel_path, file_name) if rel_path else _os.path.join(dst_path, file_name)
+                    files[dpath] = _os.path.getsize(spath)
+        return files
 
     def _file_needs_update(self, local_data, remote_path):
         """Check if local file differs from remote file
@@ -141,7 +249,20 @@ class MpyTool():
         """
         if self._force:
             return True
-        # Check remote file size first (fast)
+        # Check cache first (populated by _prefetch_remote_info)
+        if remote_path in self._remote_file_cache:
+            cached = self._remote_file_cache[remote_path]
+            if cached is None:
+                return True  # File doesn't exist or hashlib not available
+            remote_size, remote_hash = cached
+            local_size = len(local_data)
+            if local_size != remote_size:
+                return True  # Different size
+            if remote_hash is None:
+                return True  # Size matched but hash wasn't computed (shouldn't happen with prefetch)
+            local_hash = _hashlib.sha256(local_data).digest()
+            return local_hash != remote_hash
+        # Fallback to individual calls (for single file operations)
         remote_size = self._mpy.stat(remote_path)
         if remote_size is None or remote_size < 0:
             return True  # File doesn't exist or is a directory
@@ -155,24 +276,6 @@ class MpyTool():
             return True  # hashlib not available on device
         return local_hash != remote_hash
 
-    def _count_remote_files(self, path):
-        """Count files on device"""
-        stat = self._mpy.stat(path)
-        if stat is None:
-            return 0
-        if stat >= 0:  # file
-            return 1
-        # directory - count recursively
-        count = 0
-        entries = self._mpy.ls(path)
-        for name, size in entries:
-            if size is None:  # directory
-                entry_path = path.rstrip('/') + '/' + name
-                count += self._count_remote_files(entry_path)
-            else:  # file
-                count += 1
-        return count
-
     def _collect_source_paths(self, commands):
         """Collect source paths for a cp/put command (for alignment calculation)"""
         paths = []
@@ -188,29 +291,14 @@ class MpyTool():
                     src_path = '/'
                 src_path = src_path.rstrip('/') or '/'
                 if src_is_remote:
-                    # Collect all file paths from remote
                     paths.extend(self._collect_remote_paths(src_path))
                 else:
-                    # Collect all file paths from local
                     paths.extend(self._collect_local_paths(src_path))
         elif cmd == 'put' and len(commands) >= 2:
             src_path = commands[1]
             paths.extend(self._collect_local_paths(src_path))
         return paths
 
-    def _collect_local_paths(self, path):
-        """Collect all local file paths (formatted for display)"""
-        paths = []
-        if _os.path.isfile(path):
-            paths.append(self._format_local_path(path))
-        elif _os.path.isdir(path):
-            for root, dirs, files in _os.walk(path, topdown=True):
-                dirs[:] = [d for d in dirs if d not in self._exclude_dirs]
-                for f in files:
-                    full_path = _os.path.join(root, f)
-                    paths.append(self._format_local_path(full_path))
-        return paths
-
     def _collect_remote_paths(self, path):
         """Collect all remote file paths (formatted for display)"""
         paths = []
@@ -229,20 +317,96 @@ class MpyTool():
                     paths.append(':' + entry_path)
         return paths
 
+    def _collect_destination_paths(self, commands):
+        """Collect formatted destination paths for a cp/put command"""
+        if not commands:
+            return []
+        cmd = commands[0]
+        if cmd == 'cp' and len(commands) >= 3:
+            # Filter out flags
+            args = [a for a in commands[1:] if not a.startswith('-')]
+            if len(args) < 2:
+                return []
+            sources, dest = args[:-1], args[-1]
+            dest_is_remote = dest.startswith(':')
+            dest_path = (dest[1:] or '/') if dest_is_remote else dest
+            dest_is_dir = dest_path.endswith('/')
+            dst_paths = []
+            for src in sources:
+                src_is_remote = src.startswith(':')
+                src_path = ((src[1:] or '/') if src_is_remote else src).rstrip('/') or '/'
+                copy_contents = src.endswith('/')
+                if dest_is_remote and not src_is_remote:
+                    # local -> remote: reuse _collect_dst_files
+                    if _os.path.exists(src_path):
+                        files = self._collect_dst_files(src_path, dest_path.rstrip('/') or '/', not copy_contents)
+                        dst_paths.extend(':' + p for p in files)
+                elif not dest_is_remote and src_is_remote:
+                    # remote -> local
+                    dst_paths.extend(self._collect_remote_to_local_dst(src_path, dest_path, dest_is_dir, copy_contents))
+                elif dest_is_remote and src_is_remote:
+                    # remote -> remote (file only)
+                    stat = self._mpy.stat(src_path)
+                    if stat is not None and stat >= 0:
+                        basename = src_path.split('/')[-1]
+                        dst_paths.append(':' + (dest_path + basename if dest_is_dir else dest_path))
+            return dst_paths
+        elif cmd == 'put' and len(commands) >= 2:
+            src_path = commands[1]
+            dst_path = commands[2] if len(commands) > 2 else '/'
+            if _os.path.exists(src_path):
+                files = self._collect_dst_files(src_path, dst_path.rstrip('/') or '/', add_src_basename=True)
+                return [':' + p for p in files]
+        return []
+
+    def _collect_remote_to_local_dst(self, src_path, dest_path, dest_is_dir, copy_contents):
+        """Collect destination paths for remote->local copy"""
+        stat = self._mpy.stat(src_path)
+        if stat is None:
+            return []
+        base_dst = dest_path.rstrip('/') or '.'
+        if dest_is_dir and not copy_contents and src_path != '/':
+            base_dst = _os.path.join(base_dst, src_path.split('/')[-1])
+        if stat >= 0:  # file
+            if _os.path.isdir(base_dst) or dest_is_dir:
+                return [self._format_local_path(_os.path.join(base_dst, src_path.split('/')[-1]))]
+            return [self._format_local_path(base_dst)]
+        return self._collect_remote_dir_dst(src_path, base_dst)
+
+    def _collect_remote_dir_dst(self, src_path, base_dst):
+        """Collect local destination paths for remote directory download"""
+        paths = []
+        for name, size in self._mpy.ls(src_path):
+            entry_src = src_path.rstrip('/') + '/' + name
+            entry_dst = _os.path.join(base_dst, name)
+            if size is None:  # directory
+                paths.extend(self._collect_remote_dir_dst(entry_src, entry_dst))
+            else:  # file
+                paths.append(self._format_local_path(entry_dst))
+        return paths
+
     def count_files_for_command(self, commands):
         """Count files that would be transferred by cp/put command.
-        Returns (is_copy_command, file_count, source_paths)"""
-        paths = self._collect_source_paths(commands)
-        if paths:
-            return True, len(paths), paths
-        return False, 0, []
+        Returns (is_copy_command, file_count, source_paths, dest_paths)"""
+        src_paths = self._collect_source_paths(commands)
+        if src_paths:
+            dst_paths = self._collect_destination_paths(commands)
+            return True, len(src_paths), src_paths, dst_paths
+        return False, 0, [], []
 
-    def set_batch_progress(self, total_files, max_src_len=0):
+    def set_batch_progress(self, total_files, max_src_len=0, max_dst_len=0):
         """Set batch progress for consecutive copy commands"""
         self._progress_total_files = total_files
         self._progress_current_file = 0
         self._progress_max_src_len = max_src_len
+        self._progress_max_dst_len = max_dst_len
         self._batch_mode = True
+        self._stats_total_bytes = 0
+        self._stats_transferred_bytes = 0
+        self._stats_wire_bytes = 0
+        self._stats_transferred_files = 0
+        self._skipped_files = 0
+        self._stats_start_time = _time.time()
 
     def reset_batch_progress(self):
         """Reset batch progress mode"""
@@ -250,14 +414,43 @@ class MpyTool():
         self._progress_total_files = 0
         self._progress_current_file = 0
         self._progress_max_src_len = 0
+        self._progress_max_dst_len = 0
+        self._remote_file_cache.clear()
+
+    def print_copy_summary(self):
+        """Print summary after copy operation"""
+        if self._stats_start_time is None:
+            return
+        elapsed = _time.time() - self._stats_start_time
+        total = self._stats_total_bytes
+        transferred = self._stats_transferred_bytes
+        wire = self._stats_wire_bytes
+        total_files = self._stats_transferred_files + self._skipped_files
+        parts = []
+        parts.append(f"{self.format_size(transferred).strip()}")
+        if elapsed > 0:
+            speed = transferred / elapsed
+            parts.append(f"{self.format_size(speed).strip()}/s")
+        parts.append(f"{elapsed:.1f}s")
+        # Combined speedup: total file size vs actual wire bytes
+        # Includes savings from: skipped files, base64 encoding, compression
+        if wire > 0 and total > wire:
+            speedup = total / wire
+            parts.append(f"speedup {speedup:.1f}x")
+        summary = "  ".join(parts)
+        if self._skipped_files > 0:
+            file_info = f"{self._stats_transferred_files} transferred, {self._skipped_files} skipped"
+        else:
+            file_info = f"{total_files} files"
+        self.verbose(f"  {summary}  ({file_info})", color='green')
 
     def cmd_ls(self, dir_name):
         result = self._mpy.ls(dir_name)
         for name, size in result:
             if size is not None:
-                print(f'{size:8d} {name}')
+                print(f'{self.format_size(size):>9} {name}')
             else:
-                print(f'{"":8} {name}/')
+                print(f'{"":9} {name}/')
 
     @classmethod
     def print_tree(cls, tree, prefix='', print_size=True, first=True, last=True):
@@ -275,7 +468,7 @@ class MpyTool():
             sufix = '/'
         line = ''
         if print_size:
-            line += f'{size:8d} '
+            line += f'{cls.format_size(size):>9} '
         line += prefix + this_prefix + name + sufix
         print(line)
         if not sub_tree:
@@ -310,81 +503,71 @@ class MpyTool():
             data = self._mpy.get(file_name)
             print(data.decode('utf-8'))
 
+    def _upload_file(self, data, src_path, dst_path, show_progress):
+        """Upload file data to device with stats tracking and progress display"""
+        file_size = len(data)
+        self._stats_total_bytes += file_size
+        if not self._file_needs_update(data, dst_path):
+            self._skipped_files += 1
+            if show_progress and self._verbose >= 1:
+                self._progress_current_file += 1
+                self._set_progress_info(src_path, dst_path, False, True)
+                self.verbose(self._format_skip_line(file_size), color='yellow')
+            return False  # skipped
+        self._stats_transferred_bytes += file_size
+        self._stats_transferred_files += 1
+        if show_progress and self._verbose >= 1:
+            self._progress_current_file += 1
+            self._set_progress_info(src_path, dst_path, False, True)
+            encodings, wire = self._mpy.put(data, dst_path, self._progress_callback, self._compress)
+            self._stats_wire_bytes += wire
+            self._progress_complete(file_size, encodings)
+        else:
+            _, wire = self._mpy.put(data, dst_path, compress=self._compress)
+            self._stats_wire_bytes += wire
+        return True  # uploaded
+
     def _put_dir(self, src_path, dst_path, show_progress=True):
-        basename = _os.path.basename(src_path)
+        basename = _os.path.basename(_os.path.abspath(src_path))
         if basename:
             dst_path = _os.path.join(dst_path, basename)
         self.verbose(f"PUT DIR: {src_path} -> {dst_path}", 2)
+        created_dirs = set()
         for path, dirs, files in _os.walk(src_path, topdown=True):
-            dirs[:] = [d for d in dirs if d not in self._exclude_dirs]
-            basename = _os.path.basename(path)
-            if basename in self._exclude_dirs:
+            dirs[:] = [d for d in dirs if not self._is_excluded(d)]
+            files = [f for f in files if not self._is_excluded(f)]
+            if not files:
                 continue
             rel_path = _os.path.relpath(path, src_path)
-            if rel_path == '.':
-                rel_path = ''
-            rel_path = _os.path.join(dst_path, rel_path)
-            if rel_path:
+            rel_path = _os.path.join(dst_path, '' if rel_path == '.' else rel_path)
+            if rel_path and rel_path not in created_dirs:
                 self.verbose(f'MKDIR: {rel_path}', 2)
                 self._mpy.mkdir(rel_path)
+                created_dirs.add(rel_path)
             for file_name in files:
                 spath = _os.path.join(path, file_name)
-                dpath = _os.path.join(rel_path, file_name)
-                with open(spath, 'rb') as src_file:
-                    data = src_file.read()
-                # Check if file needs update
-                if not self._file_needs_update(data, dpath):
-                    self._skipped_files += 1
-                    if show_progress and self._verbose >= 1:
-                        self._progress_current_file += 1
-                        self._set_progress_info(spath, dpath, False, True)
-                        self.verbose(f"  skip {self._progress_src} (unchanged)", color='yellow')
-                    continue
-                if show_progress and self._verbose >= 1:
-                    self._progress_current_file += 1
-                    self._set_progress_info(spath, dpath, False, True)
-                    self._mpy.put(data, dpath, self._progress_callback)
-                    self._progress_complete(len(data))
-                else:
-                    self._mpy.put(data, dpath)
+                with open(spath, 'rb') as f:
+                    self._upload_file(f.read(), spath, _os.path.join(rel_path, file_name), show_progress)
 
     def _put_file(self, src_path, dst_path, show_progress=True):
         basename = _os.path.basename(src_path)
         if basename and not _os.path.basename(dst_path):
             dst_path = _os.path.join(dst_path, basename)
         self.verbose(f"PUT FILE: {src_path} -> {dst_path}", 2)
-        # Read local file
-        with open(src_path, 'rb') as src_file:
-            data = src_file.read()
-        # Check if file needs update
-        if not self._file_needs_update(data, dst_path):
-            self._skipped_files += 1
-            if show_progress and self._verbose >= 1:
-                self._progress_current_file += 1
-                self._set_progress_info(src_path, dst_path, False, True)
-                self.verbose(f"  skip {self._progress_src} (unchanged)", color='yellow')
-            return
-        # Create parent directory if needed
-        path = _os.path.dirname(dst_path)
-        if path:
-            result = self._mpy.stat(path)
-            if result is None:
-                self._mpy.mkdir(path)
-            elif result >= 0:
-                raise _mpytool.MpyError(
-                    f'Error creating file under file: {path}')
-        # Upload file
-        if show_progress and self._verbose >= 1:
-            self._progress_current_file += 1
-            self._set_progress_info(src_path, dst_path, False, True)
-            self._mpy.put(data, dst_path, self._progress_callback)
-            self._progress_complete(len(data))
-        else:
-            self._mpy.put(data, dst_path)
+        with open(src_path, 'rb') as f:
+            data = f.read()
+        parent = _os.path.dirname(dst_path)
+        if parent:
+            stat = self._mpy.stat(parent)
+            if stat is None:
+                self._mpy.mkdir(parent)
+            elif stat >= 0:
+                raise _mpytool.MpyError(f'Error creating file under file: {parent}')
+        self._upload_file(data, src_path, dst_path, show_progress)
 
     def cmd_put(self, src_path, dst_path):
         if self._verbose >= 1 and not self._batch_mode:
-            self._progress_total_files = self._count_local_files(src_path)
+            self._progress_total_files = len(self._collect_local_paths(src_path))
             self._progress_current_file = 0
         if _os.path.isdir(src_path):
             self._put_dir(src_path, dst_path)
@@ -396,7 +579,6 @@ class MpyTool():
     def _get_file(self, src_path, dst_path, show_progress=True):
         """Download single file from device"""
         self.verbose(f"GET FILE: {src_path} -> {dst_path}", 2)
-        # Create destination directory if needed
         dst_dir = _os.path.dirname(dst_path)
         if dst_dir and not _os.path.exists(dst_dir):
             _os.makedirs(dst_dir)
@@ -407,6 +589,10 @@ class MpyTool():
             self._progress_complete(len(data))
         else:
             data = self._mpy.get(src_path)
+        file_size = len(data)
+        self._stats_total_bytes += file_size
+        self._stats_transferred_bytes += file_size
+        self._stats_transferred_files += 1
         with open(dst_path, 'wb') as dst_file:
             dst_file.write(data)
 
@@ -442,8 +628,9 @@ class MpyTool():
             dst_path = dst_path.rstrip('/')
         if src_is_dir:
             if copy_contents:
-                # Copy contents of directory
                 for item in _os.listdir(src_path):
+                    if self._is_excluded(item):
+                        continue
                     item_src = _os.path.join(src_path, item)
                     if _os.path.isdir(item_src):
                         self._put_dir(item_src, dst_path)
@@ -484,7 +671,6 @@ class MpyTool():
             raise ParamsError(f'Source not found on device: {src_path}')
         if stat == -1:
             raise ParamsError('Remote-to-remote directory copy not supported yet')
-        # File copy on device
         if dst_is_dir:
             basename = src_path.split('/')[-1]
             dst_path = dst_path + basename
@@ -493,16 +679,63 @@ class MpyTool():
             self._progress_current_file += 1
             self._set_progress_info(src_path, dst_path, True, True)
             data = self._mpy.get(src_path, self._progress_callback)
-            self._mpy.put(data, dst_path)
-            self._progress_complete(len(data))
+            encodings, wire = self._mpy.put(data, dst_path, compress=self._compress)
+            self._stats_wire_bytes += wire
+            self._progress_complete(len(data), encodings)
         else:
             data = self._mpy.get(src_path)
-            self._mpy.put(data, dst_path)
+            _, wire = self._mpy.put(data, dst_path, compress=self._compress)
+            self._stats_wire_bytes += wire
+        file_size = len(data)
+        self._stats_total_bytes += file_size
+        self._stats_transferred_bytes += file_size
+        self._stats_transferred_files += 1
 
     def cmd_cp(self, *args):
         """Copy files between local and device"""
+        # Parse flags: -f/--force, -z/--compress, -Z/--no-compress
+        args = list(args)
+        force = None
+        compress = None  # None = use global setting
+        filtered_args = []
+        for a in args:
+            if a == '--force':
+                force = True
+            elif a == '--compress':
+                compress = True
+            elif a == '--no-compress':
+                compress = False
+            elif a.startswith('-') and not a.startswith('--') and len(a) > 1:
+                # Handle combined short flags like -fz, -fZ
+                flags = a[1:]
+                if 'f' in flags:
+                    force = True
+                if 'z' in flags:
+                    compress = True
+                if 'Z' in flags:
+                    compress = False
+                remaining = flags.replace('f', '').replace('z', '').replace('Z', '')
+                if remaining:
+                    filtered_args.append('-' + remaining)
+            else:
+                filtered_args.append(a)
+        args = filtered_args
         if len(args) < 2:
             raise ParamsError('cp requires source and destination')
+        # Save and set flags for this command
+        saved_force = self._force
+        saved_compress = self._compress
+        if force is not None:
+            self._force = force
+        if compress is not None:
+            self._compress = compress
+        try:
+            self._cmd_cp_impl(args)
+        finally:
+            self._force = saved_force
+            self._compress = saved_compress
+
+    def _cmd_cp_impl(self, args):
         sources = list(args[:-1])
         dest = args[-1]
         dest_is_remote = dest.startswith(':')
@@ -512,7 +745,6 @@ class MpyTool():
         dest_is_dir = dest_path.endswith('/')
         if len(sources) > 1 and not dest_is_dir:
             raise ParamsError('multiple sources require destination directory (ending with /)')
-        # Count total files for progress (only if not in batch mode)
         if self._verbose >= 1 and not self._batch_mode:
             total_files = 0
             for src in sources:
@@ -522,11 +754,24 @@ class MpyTool():
                     src_path = '/'
                 src_path_clean = src_path.rstrip('/') or '/'
                 if src_is_remote:
-                    total_files += self._count_remote_files(src_path_clean)
+                    total_files += len(self._collect_remote_paths(src_path_clean))
                 else:
-                    total_files += self._count_local_files(src_path_clean)
+                    total_files += len(self._collect_local_paths(src_path_clean))
             self._progress_total_files = total_files
             self._progress_current_file = 0
+        all_dst_files = {}
+        if dest_is_remote:
+            for src in sources:
+                if not src.startswith(':'):  # local source
+                    copy_contents = src.endswith('/')
+                    src_path = src.rstrip('/')
+                    if _os.path.exists(src_path):
+                        add_basename = not copy_contents
+                        all_dst_files.update(self._collect_dst_files(src_path, dest_path.rstrip('/') or '/', add_basename))
+            if all_dst_files and not self._batch_mode:
+                self._progress_max_dst_len = max(len(':' + p) for p in all_dst_files)
+                if not self._force:
+                    self._prefetch_remote_info(all_dst_files)
         for src in sources:
             src_is_remote = src.startswith(':')
             src_path = src[1:] if src_is_remote else src
@@ -547,7 +792,6 @@ class MpyTool():
             raise ParamsError('mv requires source and destination')
         sources = list(args[:-1])
         dest = args[-1]
-        # Validate all paths are remote
         if not dest.startswith(':'):
             raise ParamsError('mv destination must be device path (: prefix)')
         for src in sources:
@@ -564,7 +808,6 @@ class MpyTool():
             if stat is None:
                 raise ParamsError(f'Source not found on device: {src_path}')
             if dest_is_dir:
-                # Ensure destination directory exists
                 dst_dir = dest_path.rstrip('/')
                 if dst_dir and self._mpy.stat(dst_dir) is None:
                     self._mpy.mkdir(dst_dir)
@@ -595,8 +838,8 @@ class MpyTool():
                 self.verbose(f"DELETE: {path}", 1)
                 self._mpy.delete(path)
 
-    def cmd_follow(self):
-        self.verbose("FOLLOW (Ctrl+C to stop)", 1)
+    def cmd_monitor(self):
+        self.verbose("MONITOR (Ctrl+C to stop)", 1)
         try:
             while True:
                 line = self._conn.read_line()
@@ -604,7 +847,7 @@ class MpyTool():
                 print(line)
         except KeyboardInterrupt:
             self.verbose('', level=0, overwrite=True)  # newline after ^C
-        except _mpytool.ConnError as err:
+        except (_mpytool.ConnError, OSError) as err:
             if self._log:
                 self._log.error(err)
 
@@ -626,80 +869,291 @@ class MpyTool():
 
     @staticmethod
     def format_size(size):
-        """Format size in bytes to human readable format with 3+ digits"""
-        if size < 1000:
-            return f"{size} B"
-        for unit in ('KB', 'MB', 'GB', 'TB'):
+        """Format size in bytes to human readable format (like ls -h)"""
+        if size < 1024:
+            return f"{int(size)}B"
+        for unit in ('K', 'M', 'G', 'T'):
             size /= 1024
             if size < 10:
-                return f"{size:.2f} {unit}"
+                return f"{size:.2f}{unit}"
             if size < 100:
-                return f"{size:.1f} {unit}"
-            if size < 1000 or unit == 'TB':
-                return f"{size:.0f} {unit}"
-        return f"{size:.0f} TB"
+                return f"{size:.1f}{unit}"
+            if size < 1024 or unit == 'T':
+                return f"{size:.0f}{unit}"
+        return f"{size:.0f}T"
+
+    def cmd_paths(self, dir_name='.'):
+        """Print all paths (for shell completion) - undocumented"""
+        tree = self._mpy.tree(dir_name)
+        self._print_paths(tree, '')
+
+    def _print_paths(self, entry, prefix):
+        """Recursively print paths from tree structure"""
+        name, size, children = entry
+        if name in ('.', './'):
+            path = ''
+        else:
+            path = prefix + name
+        if children is None:
+            # File
+            print(path)
+        else:
+            # Directory
+            if path:
+                print(path + '/')
+            for child in children:
+                self._print_paths(child, path + '/' if path else '')
+
+    def cmd_ota(self, firmware_path):
+        """OTA firmware update from local .app-bin file"""
+        self.verbose("OTA UPDATE", 1)
+        if not _os.path.isfile(firmware_path):
+            raise ParamsError(f"Firmware file not found: {firmware_path}")
+
+        with open(firmware_path, 'rb') as f:
+            firmware = f.read()
+
+        fw_size = len(firmware)
+        self.verbose(f"  Firmware: {self.format_size(fw_size)}", 1)
+        info = self._mpy.partitions()
+        if not info['next_ota']:
+            raise _mpytool.MpyError("OTA not available (no OTA partitions)")
+
+        self.verbose(f"  Target: {info['next_ota']} ({self.format_size(info['next_ota_size'])})", 1)
+        use_compress = self._mpy._detect_deflate()
+        chunk_size = self._mpy._detect_chunk_size()
+        chunk_str = f"{chunk_size // 1024}K" if chunk_size >= 1024 else str(chunk_size)
+        self.verbose(f"  Writing (chunk: {chunk_str}, compress: {'on' if use_compress else 'off'})...", 1)
+        start_time = _time.time()
+
+        def progress_callback(transferred, total, wire_bytes):
+            if self._verbose >= 1:
+                pct = transferred * 100 // total
+                elapsed = _time.time() - start_time
+                speed = transferred / elapsed / 1024 if elapsed > 0 else 0
+                line = f"  Writing: {pct:3d}% {self.format_size(transferred):>6} / {self.format_size(total)}  {speed:.1f} KB/s"
+                self.verbose(line, color='cyan', end='', overwrite=True)
+
+        result = self._mpy.ota_write(firmware, progress_callback, self._compress)
+        elapsed = _time.time() - start_time
+        speed = fw_size / elapsed / 1024 if elapsed > 0 else 0
+        ratio = fw_size / result['wire_bytes'] if result['wire_bytes'] > 0 else 1
+        self.verbose(
+            f"  Writing: 100% {self.format_size(fw_size):>6}  {elapsed:.1f}s  {speed:.1f} KB/s  ratio {ratio:.2f}x",
+            color='cyan', overwrite=True
+        )
+
+        self.verbose(f"  OTA complete! Use 'mreset' to boot into new firmware.", 1, color='green')
+
+    def cmd_flash(self):
+        """Show flash information (auto-detect platform)"""
+        self.verbose("FLASH", 2)
+        platform = self._mpy.platform()['platform']
+
+        if platform == 'rp2':
+            self._cmd_flash_rp2()
+        elif platform == 'esp32':
+            self._cmd_flash_esp32()
+        else:
+            raise _mpytool.MpyError(f"Flash info not supported for platform: {platform}")
+
+    def _cmd_flash_rp2(self):
+        """Show RP2 flash information"""
+        info = self._mpy.flash_info()
+        print(f"Platform:    RP2")
+        print(f"Flash size:  {self.format_size(info['size'])}")
+        print(f"Block size:  {info['block_size']} bytes")
+        print(f"Block count: {info['block_count']}")
+        fs_line = f"Filesystem:  {info['filesystem']}"
+        # For FAT, show cluster size if detected from magic
+        if info.get('fs_block_size'):
+            fs_line += f" (cluster: {self.format_size(info['fs_block_size'])})"
+        if info['filesystem'] == 'unknown' and info.get('magic'):
+            magic_hex = ' '.join(f'{b:02x}' for b in info['magic'])
+            fs_line += f"  (magic: {magic_hex})"
+        print(fs_line)
+
+    def _make_progress(self, action, label=None):
+        """Create progress callback for flash operations"""
+        def progress(transferred, total, *_):
+            if self._verbose >= 1:
+                pct = (transferred / total * 100) if total > 0 else 0
+                prefix = f"{action} {label}" if label else action
+                self.verbose(
+                    f"  {prefix}: {pct:.0f}% {self.format_size(transferred)} / {self.format_size(total)}",
+                    color='cyan', end='', overwrite=True)
+        return progress
+
+    def cmd_flash_read(self, dest_path, label=None):
+        """Read flash/partition content to file"""
+        if label:
+            self.verbose(f"FLASH READ {label} -> {dest_path}", 1)
+        else:
+            self.verbose(f"FLASH READ -> {dest_path}", 1)
+
+        data = self._mpy.flash_read(label=label, progress_callback=self._make_progress("reading", label))
+
+        if self._verbose >= 1:
+            print()  # newline after progress
+
+        with open(dest_path, 'wb') as f:
+            f.write(data)
+
+        self.verbose(f"  saved {self.format_size(len(data))} to {dest_path}", 1, color='green')
+
+    def cmd_flash_write(self, src_path, label=None):
+        """Write file content to flash/partition"""
+        if label:
+            self.verbose(f"FLASH WRITE {src_path} -> {label}", 1)
+        else:
+            self.verbose(f"FLASH WRITE {src_path}", 1)
+
+        with open(src_path, 'rb') as f:
+            data = f.read()
+
+        result = self._mpy.flash_write(
+            data, label=label,
+            progress_callback=self._make_progress("writing", label),
+            compress=self._compress)
+
+        if self._verbose >= 1:
+            print()  # newline after progress
+
+        target = label or "flash"
+        comp_info = " (compressed)" if result.get('compressed') else ""
+        self.verbose(f"  wrote {self.format_size(result['written'])} to {target}{comp_info}", 1, color='green')
+
+    def cmd_flash_erase(self, label=None, full=False):
+        """Erase flash/partition (filesystem reset)"""
+        mode = "full" if full else "quick"
+        if label:
+            self.verbose(f"FLASH ERASE {label} ({mode})", 1)
+        else:
+            self.verbose(f"FLASH ERASE ({mode})", 1)
+
+        result = self._mpy.flash_erase(label=label, full=full, progress_callback=self._make_progress("erasing", label))
+
+        if self._verbose >= 1:
+            print()  # newline after progress
+
+        target = label or "flash"
+        self.verbose(f"  erased {self.format_size(result['erased'])} from {target}", 1, color='green')
+        if not label:
+            self.verbose("  filesystem will be recreated on next boot", 1, color='yellow')
+
+    def _cmd_flash_esp32(self):
+        """List ESP32 partitions"""
+        info = self._mpy.partitions()
+        print(f"{'Label':<12} {'Type':<8} {'Subtype':<10} {'Address':>10} {'Size':>10} "
+              f"{'Block':>8} {'Actual FS':<12} {'Flags'}")
+        print("-" * 90)
+
+        for p in info['partitions']:
+            flags = []
+            if p['encrypted']:
+                flags.append('enc')
+            if p['running']:
+                flags.append('running')
+            # Block size column
+            block_str = ''
+            if p.get('fs_block_size'):
+                block_str = self.format_size(p['fs_block_size'])
+            # Filesystem column
+            fs_info = ''
+            if p.get('filesystem'):
+                fs_info = p['filesystem']
+                # For FAT, append cluster size
+                if p.get('fs_cluster_size'):
+                    fs_info += f" ({self.format_size(p['fs_cluster_size'])})"
+            print(f"{p['label']:<12} {p['type_name']:<8} {p['subtype_name']:<10} "
+                  f"{p['offset']:>#10x} {self.format_size(p['size']):>10} "
+                  f"{block_str:>8} {fs_info:<12} {', '.join(flags)}")
+
+        if info['boot']:
+            print(f"\nBoot partition: {info['boot']}")
+        if info['next_ota']:
+            print(f"Next OTA:       {info['next_ota']}")
 
     def cmd_info(self):
         self.verbose("INFO", 2)
-        self._mpy.comm.exec("import sys, gc, os")
-        platform = self._mpy.comm.exec_eval("repr(sys.platform)")
-        version = self._mpy.comm.exec_eval("repr(sys.version)")
-        impl = self._mpy.comm.exec_eval("repr(sys.implementation.name)")
-        gc_free = self._mpy.comm.exec_eval("gc.mem_free()")
-        gc_alloc = self._mpy.comm.exec_eval("gc.mem_alloc()")
-        gc_total = gc_free + gc_alloc
-        gc_pct = (gc_alloc / gc_total * 100) if gc_total > 0 else 0
-        try:
-            uname = self._mpy.comm.exec_eval("tuple(os.uname())")
-            machine = uname[4] if len(uname) > 4 else None
-        except _mpytool.MpyError:
-            machine = None
-        # Collect filesystem info - root and any different mount points
-        fs_info = []
+        plat = self._mpy.platform()
+        print(f"Platform:    {plat['platform']}")
+        print(f"Version:     {plat['version']}")
+        print(f"Impl:        {plat['impl']}")
+        if plat['machine']:
+            print(f"Machine:     {plat['machine']}")
+        uid = self._mpy.unique_id()
+        if uid:
+            print(f"Serial:      {uid}")
+        for iface, mac in self._mpy.mac_addresses():
+            print(f"MAC {iface + ':':<8} {mac}")
+        mem = self._mpy.memory()
+        mem_pct = (mem['alloc'] / mem['total'] * 100) if mem['total'] > 0 else 0
+        print(f"Memory:      {self.format_size(mem['alloc'])} / {self.format_size(mem['total'])} ({mem_pct:.2f}%)")
+        for fs in self._mpy.filesystems():
+            label = "Flash:" if fs['mount'] == '/' else fs['mount'] + ':'
+            fs_pct = (fs['used'] / fs['total'] * 100) if fs['total'] > 0 else 0
+            print(f"{label:12} {self.format_size(fs['used'])} / {self.format_size(fs['total'])} ({fs_pct:.2f}%)")
+
+    def cmd_mreset(self, reconnect=True):
+        """MCU reset using machine.reset() with optional auto-reconnect"""
+        self.verbose("MRESET", 1)
+        if reconnect:
+            try:
+                self.verbose("  reconnecting...", 1, color='yellow')
+                self._mpy.machine_reset(reconnect=True)
+                self.verbose("  connected", 1, color='green')
+            except (_mpytool.ConnError, OSError) as err:
+                self.verbose(f"  reconnect failed: {err}", 1, color='red')
+                raise _mpytool.ConnError(f"Reconnect failed: {err}")
+        else:
+            self._mpy.machine_reset(reconnect=False)
+
+    def cmd_sreset(self):
+        """Soft reset in raw REPL - clears RAM but doesn't run boot.py/main.py"""
+        self.verbose("SRESET", 1)
+        self._mpy.soft_reset_raw()
+
+    def cmd_rtsreset(self, reconnect=True):
+        """Hardware reset device using RTS signal with optional auto-reconnect"""
+        self.verbose("RTSRESET", 1)
         try:
-            fs_stat = self._mpy.comm.exec_eval("os.statvfs('/')")
-            fs_total = fs_stat[0] * fs_stat[2]
-            fs_free = fs_stat[0] * fs_stat[3]
-            if fs_total > 0:
-                fs_info.append({
-                    'mount': '/', 'total': fs_total,
-                    'used': fs_total - fs_free,
-                    'pct': ((fs_total - fs_free) / fs_total * 100)
-                })
-        except _mpytool.MpyError:
-            pass
-        # Check subdirectories for additional mount points
+            self._mpy.hard_reset()
+            if reconnect:
+                self.verbose("  reconnecting...", 1, color='yellow')
+                _time.sleep(1.0)  # Wait for device to boot
+                self._mpy._conn.reconnect()
+                self.verbose("  connected", 1, color='green')
+        except NotImplementedError:
+            raise _mpytool.MpyError("Hardware reset not available (serial only)")
+        except (_mpytool.ConnError, OSError) as err:
+            self.verbose(f"  reconnect failed: {err}", 1, color='red')
+            raise _mpytool.ConnError(f"Reconnect failed: {err}")
+
+    def cmd_bootloader(self):
+        """Enter bootloader using machine.bootloader()"""
+        self.verbose("BOOTLOADER", 1)
+        self._mpy.machine_bootloader()
+
+    def cmd_dtrboot(self):
+        """Enter bootloader using DTR/RTS signals (ESP32 only)
+
+        Auto-detects port type:
+        - USB-UART: classic DTR/RTS sequence (GPIO0 directly connected)
+        - USB-CDC: USB-JTAG-Serial sequence (ESP32-S/C native USB)
+        """
+        self.verbose("DTRBOOT", 1)
         try:
-            root_dirs = self._mpy.comm.exec_eval("[d[0] for d in os.ilistdir('/') if d[1] == 0x4000]")
-            for dirname in root_dirs:
-                try:
-                    path = '/' + dirname
-                    sub_stat = self._mpy.comm.exec_eval(f"os.statvfs('{path}')")
-                    sub_total = sub_stat[0] * sub_stat[2]
-                    sub_free = sub_stat[0] * sub_stat[3]
-                    # Skip if same as root or zero size
-                    if sub_total == 0 or any(f['total'] == sub_total for f in fs_info):
-                        continue
-                    fs_info.append({
-                        'mount': path, 'total': sub_total,
-                        'used': sub_total - sub_free,
-                        'pct': ((sub_total - sub_free) / sub_total * 100)
-                    })
-                except _mpytool.MpyError:
-                    pass
-        except _mpytool.MpyError:
-            pass
-        print(f"Platform:    {platform}")
-        print(f"Version:     {version}")
-        print(f"Impl:        {impl}")
-        if machine:
-            print(f"Machine:     {machine}")
-        print(f"Memory:      {self.format_size(gc_alloc)} / {self.format_size(gc_total)} ({gc_pct:.2f}%)")
-        for fs in fs_info:
-            label = "Flash:" if fs['mount'] == '/' else fs['mount'] + ':'
-            print(f"{label:12} {self.format_size(fs['used'])} / {self.format_size(fs['total'])} ({fs['pct']:.2f}%)")
+            self._mpy.reset_to_bootloader()
+        except NotImplementedError:
+            raise _mpytool.MpyError("DTR boot not available (serial only)")
+
+    def cmd_sleep(self, seconds):
+        """Sleep for specified number of seconds"""
+        self.verbose(f"SLEEP {seconds}s", 1)
+        _time.sleep(seconds)
 
-    def process_commands(self, commands):
+    def process_commands(self, commands, is_last_group=False):
         try:
             while commands:
                 command = commands.pop(0)
@@ -741,10 +1195,15 @@ class MpyTool():
                     break
                 elif command == 'reset':
                     self.verbose("RESET", 1)
-                    self._mpy.comm.soft_reset()
-                    self._mpy.reset_state()
-                elif command == 'follow':
-                    self.cmd_follow()
+                    self._mpy.soft_reset()
+                elif command == 'mreset':
+                    # Reconnect only if there are more commands (in this or next group)
+                    has_more = bool(commands) or not is_last_group
+                    self.cmd_mreset(reconnect=has_more)
+                elif command == 'sreset':
+                    self.cmd_sreset()
+                elif command in ('monitor', 'follow'):
+                    self.cmd_monitor()
                     break
                 elif command == 'repl':
                     self.cmd_repl()
@@ -757,6 +1216,72 @@ class MpyTool():
                         raise ParamsError('missing code for exec command')
                 elif command == 'info':
                     self.cmd_info()
+                elif command == 'flash':
+                    if commands and commands[0] == 'read':
+                        commands.pop(0)
+                        if len(commands) >= 2:
+                            # ESP32: flash read <label> <file>
+                            label = commands.pop(0)
+                            dest_path = commands.pop(0)
+                            self.cmd_flash_read(dest_path, label=label)
+                        elif len(commands) == 1:
+                            # RP2: flash read <file>
+                            dest_path = commands.pop(0)
+                            self.cmd_flash_read(dest_path)
+                        else:
+                            raise ParamsError('flash read requires destination file')
+                    elif commands and commands[0] == 'write':
+                        commands.pop(0)
+                        if len(commands) >= 2:
+                            # ESP32: flash write <label> <file>
+                            label = commands.pop(0)
+                            src_path = commands.pop(0)
+                            self.cmd_flash_write(src_path, label=label)
+                        elif len(commands) == 1:
+                            # RP2: flash write <file>
+                            src_path = commands.pop(0)
+                            self.cmd_flash_write(src_path)
+                        else:
+                            raise ParamsError('flash write requires source file')
+                    elif commands and commands[0] == 'erase':
+                        commands.pop(0)
+                        # Check for --full flag and optional label
+                        full = False
+                        label = None
+                        while commands and (commands[0] == '--full' or not commands[0].startswith('-')):
+                            if commands[0] == '--full':
+                                full = True
+                                commands.pop(0)
+                            elif label is None:
+                                label = commands.pop(0)
+                            else:
+                                break
+                        self.cmd_flash_erase(label=label, full=full)
+                    else:
+                        self.cmd_flash()
+                elif command == 'ota':
+                    if commands:
+                        firmware_path = commands.pop(0)
+                        self.cmd_ota(firmware_path)
+                    else:
+                        raise ParamsError('ota requires firmware file path')
+                elif command == 'rtsreset':
+                    # Reconnect only if there are more commands (in this or next group)
+                    has_more = bool(commands) or not is_last_group
+                    self.cmd_rtsreset(reconnect=has_more)
+                elif command == 'bootloader':
+                    self.cmd_bootloader()
+                elif command == 'dtrboot':
+                    self.cmd_dtrboot()
+                elif command == 'sleep':
+                    if commands:
+                        try:
+                            seconds = float(commands.pop(0))
+                        except ValueError:
+                            raise ParamsError('sleep requires a number (seconds)')
+                        self.cmd_sleep(seconds)
+                    else:
+                        raise ParamsError('sleep requires a number (seconds)')
                 elif command == 'cp':
                     if len(commands) >= 2:
                         self.cmd_cp(*commands)
@@ -767,6 +1292,12 @@ class MpyTool():
                         self.cmd_mv(*commands)
                         break
                     raise ParamsError('mv requires source and destination')
+                elif command == '_paths':
+                    # Undocumented: for shell completion
+                    if commands:
+                        self.cmd_paths(commands.pop(0))
+                    else:
+                        self.cmd_paths()
                 else:
                     raise ParamsError(f"unknown command: '{command}'")
         except (_mpytool.MpyError, _mpytool.ConnError) as err:
@@ -785,62 +1316,98 @@ _COMMANDS_HELP_STR = """
 List of available commands:
   ls [{path}]                   list files and its sizes
   tree [{path}]                 list tree of structure and sizes
-  cp {src} [...] {dst}          copy files (: prefix = device path)
+  cp [-f] {src} [...] {dst}     copy files (: prefix = device path, -f = force)
   mv {src} [...] {dst}          move/rename on device (: prefix required)
   get {path} [...]              get file and print it
   put {src_path} [{dst_path}]   put file or directory to destination
   mkdir {path} [...]            create directory (also create all parents)
   delete {path} [...]           remove file/dir (path/ = contents only)
-  reset                         soft reset
-  follow                        print log of running program
+  reset                         soft reset (Ctrl-D, runs boot.py/main.py)
+  sreset                        soft reset in raw REPL (clears RAM only)
+  mreset                        MCU reset (machine.reset, auto-reconnect)
+  rtsreset                      RTS reset (hardware reset via RTS signal)
+  bootloader                    enter bootloader (machine.bootloader)
+  dtrboot                       enter bootloader via DTR/RTS (ESP32 only)
+  monitor                       print output of running program
   repl                          enter REPL mode [UNIX OS ONLY]
   exec {code}                   execute Python code on device
   info                          show device information
+  flash                         show flash info (RP2) or partitions (ESP32)
+  flash read [{label}] {file}   read flash/partition to file
+  flash write [{label}] {file}  write file to flash/partition
+  flash erase [{label}] [--full]  erase flash/partition
+  ota {firmware.app-bin}        OTA firmware update (ESP32 only)
+  sleep {seconds}               sleep for specified seconds
 Aliases:
   dir                           alias to ls
   cat                           alias to get
   del, rm                       alias to delete
+  follow                        alias to monitor
 Use -- to separate multiple commands:
-  mpytool put main.py / -- reset -- follow
+  mpytool put main.py / -- reset -- monitor
 """
 
 
 def _run_commands(mpy_tool, command_groups, with_progress=True):
     """Execute command groups with optional batch progress tracking"""
     if not with_progress:
-        for commands in command_groups:
-            mpy_tool.process_commands(commands)
+        for i, commands in enumerate(command_groups):
+            is_last = (i == len(command_groups) - 1)
+            mpy_tool.process_commands(commands, is_last_group=is_last)
         return
-    # Pre-scan to identify consecutive copy command batches (for progress)
     i = 0
     while i < len(command_groups):
-        is_copy, count, paths = mpy_tool.count_files_for_command(command_groups[i])
+        is_copy, count, src_paths, dst_paths = mpy_tool.count_files_for_command(command_groups[i])
         if not is_copy:
-            mpy_tool.process_commands(command_groups[i])
+            is_last = (i == len(command_groups) - 1)
+            mpy_tool.process_commands(command_groups[i], is_last_group=is_last)
             i += 1
             continue
-        # Collect consecutive copy commands into a batch
         batch_total = count
-        all_paths = paths
+        all_src_paths = src_paths
+        all_dst_paths = dst_paths
         batch_start = i
         j = i + 1
         while j < len(command_groups):
-            is_copy_j, count_j, paths_j = mpy_tool.count_files_for_command(command_groups[j])
+            is_copy_j, count_j, src_paths_j, dst_paths_j = mpy_tool.count_files_for_command(command_groups[j])
             if not is_copy_j:
                 break
             batch_total += count_j
-            all_paths.extend(paths_j)
+            all_src_paths.extend(src_paths_j)
+            all_dst_paths.extend(dst_paths_j)
             j += 1
-        # Execute batch with combined count
-        max_src_len = max(len(p) for p in all_paths) if all_paths else 0
-        mpy_tool.verbose("COPY", 1)
-        mpy_tool.set_batch_progress(batch_total, max_src_len)
+        max_src_len = max(len(p) for p in all_src_paths) if all_src_paths else 0
+        max_dst_len = max(len(p) for p in all_dst_paths) if all_dst_paths else 0
+        mpy_tool.print_transfer_info()
+        mpy_tool.set_batch_progress(batch_total, max_src_len, max_dst_len)
         for k in range(batch_start, j):
-            mpy_tool.process_commands(command_groups[k])
+            is_last = (k == j - 1) and (j == len(command_groups))
+            mpy_tool.process_commands(command_groups[k], is_last_group=is_last)
+        mpy_tool.print_copy_summary()
         mpy_tool.reset_batch_progress()
         i = j
 
 
+def _parse_chunk_size(value):
+    """Parse chunk size value (e.g., '1K', '2K', '4096')"""
+    valid = {512, 1024, 2048, 4096, 8192, 16384, 32768}
+    val = value.upper()
+    if val.endswith('K'):
+        try:
+            num = int(val[:-1]) * 1024
+        except ValueError:
+            raise _argparse.ArgumentTypeError(f"invalid chunk size: {value}")
+    else:
+        try:
+            num = int(value)
+        except ValueError:
+            raise _argparse.ArgumentTypeError(f"invalid chunk size: {value}")
+    if num not in valid:
+        valid_str = ', '.join(f'{v//1024}K' if v >= 1024 else str(v) for v in sorted(valid))
+        raise _argparse.ArgumentTypeError(f"chunk size must be one of: {valid_str}")
+    return num
+
+
 def main():
     """Main"""
     _description = _about["Summary"] if _about else None
@@ -860,10 +1427,17 @@ def main():
     parser.add_argument(
         '-q', '--quiet', action='store_true', help='quiet mode (no progress)')
     parser.add_argument(
-        '-f', '--force', action='store_true', help='force copy even if unchanged')
+        "-e", "--exclude", type=str, action='append', dest='exclude',
+        help='exclude files/dirs (wildcards: *, ?), default: *.pyc, .*')
+    parser.add_argument(
+        '-f', '--force', action='store_true', help='force overwrite (skip unchanged check)')
+    parser.add_argument(
+        '-z', '--compress', action='store_true', default=None, help='force compression')
     parser.add_argument(
-        "-e", "--exclude-dir", type=str, action='append', help='exclude dir, '
-        'by default are excluded directories: __pycache__, .git, .svn')
+        '-Z', '--no-compress', action='store_true', help='disable compression')
+    parser.add_argument(
+        '-c', '--chunk-size', type=_parse_chunk_size, metavar='SIZE',
+        help='transfer chunk size: 512, 1K, 2K, 4K, 8K, 16K, 32K (default: auto)')
     parser.add_argument('commands', nargs=_argparse.REMAINDER, help='commands')
     args = parser.parse_args()
     # Convert to numeric level: 0=quiet, 1=progress, 2=verbose
@@ -886,9 +1460,11 @@ def main():
             return
         if len(ports) == 1:
             port = ports[0]
-            log.verbose(f"Using {port}", level=1)
+            log.verbose(f"Using {port}", level=2)
         else:
-            log.error("Multiple serial ports found: %s. Use -p to specify one.", ", ".join(ports))
+            log.error("Multiple serial ports found. Use -p to specify one:")
+            for p in ports:
+                print(f"  {p}")
             return
     try:
         if port:
@@ -900,13 +1476,23 @@ def main():
     except _mpytool.ConnError as err:
         log.error(err)
         return
-    mpy_tool = MpyTool(conn, log=log, verbose=log, exclude_dirs=args.exclude_dir, force=args.force)
+    # Determine compression setting: None=auto, True=force, False=disable
+    compress = None
+    if args.no_compress:
+        compress = False
+    elif args.compress:
+        compress = True
+    mpy_tool = MpyTool(
+        conn, log=log, verbose=log, exclude_dirs=args.exclude,
+        force=args.force, compress=compress, chunk_size=args.chunk_size)
     command_groups = _utils.split_commands(args.commands)
     try:
         _run_commands(mpy_tool, command_groups, with_progress=(args.verbose >= 1))
     except KeyboardInterrupt:
         # Clear partial progress line and show clean message
         log.verbose('Interrupted', level=0, overwrite=True)
+    except (_mpytool.MpyError, _mpytool.ConnError, _mpytool.Timeout) as err:
+        log.error(err)
 
 
 if __name__ == '__main__':