added wipe command (rm :/ -- reset --machine)

Author: pavelrevak

README.md

@@ -16,6 +16,8 @@ It is an alternative to the official [mpremote](https://docs.micropython.org/en/
   (CP2102, CH340)
 - **Multiple reset options** - soft, MCU, hardware (RTS),
   bootloader entry
+- **Wipe device** - erase the whole filesystem and machine-reset
+  for a clean slate (handy at the start of automated tests)
 - **General-purpose serial terminal** - `repl` and `monitor` work
   with any serial device
 - **Mount local directory** - VFS mount (read-only or read-write)
@@ -255,6 +257,30 @@ $ mpytool sleep 2            # sleep for 2 seconds (useful between commands)
 SLEEP 2.0s
 ```
 
+### Wipe device (erase all files + machine reset)
+```
+$ mpytool wipe               # delete everything from / then machine.reset()
+WIPE
+  rm /boot.py
+  rm /main.py
+  rm /lib
+  reset
+
+$ mpytool wipe -- ls         # wipe, reconnect, then list (now empty)
+WIPE
+  rm /main.py
+  reset, reconnected
+LS:
+```
+
+`wipe` erases the whole filesystem (recursive delete of `/`) and then does a
+full `machine.reset()` — a soft reset would leave open sockets, WiFi and
+mounted VFS alive, so machine reset is used for a true clean slate. It **never
+prompts** (mpytool has no interactive mode); `-y`/`--yes` is accepted as a
+no-op. When `wipe` is the last command it just resets and exits; when more
+commands follow it reconnects first (use `-t SECONDS` for the reconnect
+timeout). See [README_API.md](README_API.md) for `Mpy.wipe()`.
+
 ### Serial terminal and monitor (general purpose)
 ```
 $ mpytool repl                       # auto-detect port, 115200 baud

README_API.md

@@ -892,7 +892,7 @@ Soft reset in raw REPL mode (clears RAM only, doesn't run boot.py/main.py).
 mpy.soft_reset_raw()
 ```
 
-#### machine_reset(reconnect=True)
+#### machine_reset(reconnect=True, timeout=None)
 
 MCU reset using `machine.reset()`.
 
@@ -902,6 +902,7 @@ mpy.machine_reset(reconnect=True)
 
 **Parameters:**
 - `reconnect` (bool): If True, attempt to reconnect after reset (for USB-CDC ports)
+- `timeout` (int): Reconnect timeout in seconds (None = default)
 
 #### hard_reset()
 
@@ -914,6 +915,34 @@ mpy.hard_reset()
 **Raises:**
 - `NotImplementedError`: If connection doesn't support hardware reset
 
+#### wipe(reconnect=True, timeout=None, on_delete=None)
+
+Erase all files from the filesystem root, then `machine.reset()` the device.
+
+Recursively deletes every entry in `/`, then performs a full machine reset so
+runtime state (open sockets, WiFi, mounted VFS) is dropped too — a soft reset
+would leave those alive. Intended for a clean slate, e.g. at the start of
+integration tests.
+
+```python
+# Clean slate at the start of a test
+mpy.wipe()
+
+# Wipe without waiting to reconnect
+mpy.wipe(reconnect=False)
+
+# Show what gets removed
+mpy.wipe(on_delete=lambda path: print(f"removing {path}"))
+```
+
+**Parameters:**
+- `reconnect` (bool): If True, wait for the device to come back after reset
+- `timeout` (int): Reconnect timeout in seconds (None = default)
+- `on_delete` (callable): Optional `callback(path)` invoked before each delete
+
+**Returns:**
+- `bool`: True if reconnected after reset, False otherwise
+
 ### Flash/Partition Methods
 
 #### partitions()

mpytool/mpy.py

@@ -1329,6 +1329,29 @@ def machine_reset(self, reconnect=True, timeout=None):
             return True
         return False
 
+    def wipe(self, reconnect=True, timeout=None, on_delete=None):
+        """Erase all files from filesystem root, then machine-reset device
+
+        Deletes every entry in '/' recursively, then performs a full
+        machine.reset() so runtime state (open sockets, WiFi, mounted VFS,
+        etc.) is dropped too - a soft reset would leave those alive. Intended
+        for a clean slate, e.g. at the start of integration tests.
+
+        Arguments:
+            reconnect: if True, wait for the device to come back after reset
+            timeout: reconnect timeout in seconds (None = default)
+            on_delete: optional callback(path) invoked before each delete
+
+        Returns:
+            True if reconnected after reset, False otherwise
+        """
+        for name, _ in self.ls('/'):
+            path = '/' + name
+            if on_delete is not None:
+                on_delete(path)
+            self.delete(path)
+        return self.machine_reset(reconnect=reconnect, timeout=timeout)
+
     def machine_bootloader(self):
         """Enter bootloader using machine.bootloader()
 

mpytool/mpytool.py

@@ -31,7 +31,7 @@
 # Order of commands in help and completion
 _CMD_ORDER = [
     'ls', 'tree', 'cat', 'cp', 'mv', 'mkdir', 'rm', 'pwd', 'cd', 'path',
-    'stop', 'reset', 'monitor', 'repl', 'exec', 'run', 'edit', 'info',
+    'stop', 'reset', 'wipe', 'monitor', 'repl', 'exec', 'run', 'edit', 'info',
     'rtc', 'flash', 'mount', 'ln', 'speedtest', 'sleep', 'ports',
 ]
 
@@ -770,6 +770,21 @@ def cmd_reset(self, mode='soft', reconnect=True, timeout=None):
             except (NotImplementedError, _mpytool.ConnError) as err:
                 raise _mpytool.MpyError(f"Bootloader reset failed: {err}")
 
+    def cmd_wipe(self, reconnect=True, timeout=None):
+        """Erase all files from root, then machine-reset the device"""
+        self.verbose("WIPE", 1)
+        try:
+            self.mpy.wipe(
+                reconnect=reconnect, timeout=timeout,
+                on_delete=lambda path: self.verbose(f"  rm {path}", 1))
+        except (_mpytool.ConnError, OSError) as err:
+            self.verbose(f"  reconnect failed: {err}", 1, color='red')
+            raise _mpytool.ConnError(f"Reconnect failed: {err}")
+        if reconnect:
+            self.verbose("  reset, reconnected", 1, color='green')
+        else:
+            self.verbose("  reset", 1)
+
     @command('ls', 'List files and directories on device.')
     @argument('path', nargs='?', default=':', metavar='remote',
         type=_normalize_path_arg, help='device path (default: CWD)')
@@ -922,6 +937,18 @@ def _dispatch_reset(self, commands, is_last_group):
         reconnect = has_more if mode in ('machine', 'rts') else True
         self.cmd_reset(mode=mode, reconnect=reconnect, timeout=args.timeout)
 
+    @command('wipe', 'Erase ALL files and machine-reset the device.')
+    @option('-y', '--yes', action='store_true',
+        help='no-op (wipe never prompts), accepted for convenience')
+    @option('-t', '--timeout', type=int,
+        help='reconnect timeout in seconds')
+    def _dispatch_wipe(self, commands, is_last_group):
+        args, commands[:] = _make_parser(
+            self._dispatch_wipe).parse_known_args(commands)
+        # Reconnect only if more work follows; pointless if wipe is last.
+        has_more = bool(commands) or not is_last_group
+        self.cmd_wipe(reconnect=has_more, timeout=args.timeout)
+
     @command('monitor', 'Monitor device output until program ends.')
     @option('-f', '--follow', action='store_true',
         help='follow output continuously (Ctrl-C to stop)')
@@ -1441,7 +1468,7 @@ def _dispatch_args(self, commands, is_last_group):
 
     _COMMANDS = frozenset({
         'ls', 'tree', 'cat', 'mkdir', 'rm', 'pwd', 'cd', 'path',
-        'reset', 'stop', 'monitor', 'repl', 'exec', 'run', 'edit', 'info',
+        'reset', 'wipe', 'stop', 'monitor', 'repl', 'exec', 'run', 'edit', 'info',
         'rtc', 'flash', 'sleep', 'cp', 'mv', 'mount', 'ln', 'speedtest',
         'ports', '_paths', '_commands', '_options', '_args',
     })

tests/test_cli.py

@@ -137,6 +137,12 @@ def test_reset_help(self):
             'soft' in result.stdout.lower() or
             'hard' in result.stdout.lower())
 
+    def test_wipe_help(self):
+        """mpytool wipe --help shows wipe usage"""
+        result = run_mpytool('wipe', '--help')
+        self.assertEqual(result.returncode, 0)
+        self.assertIn('erase', result.stdout.lower())
+
     def test_mount_help(self):
         """mpytool mount --help shows mount usage"""
         result = run_mpytool('mount', '--help')

tests/test_mpy.py

@@ -484,6 +484,61 @@ def test_chdir_to_parent(self):
         self.assertIn("os.chdir('..')", call_args)
 
 
+class TestWipe(unittest.TestCase):
+    """Tests for Mpy.wipe method"""
+
+    def setUp(self):
+        self.mock_conn = Mock()
+        self.mpy = Mpy(self.mock_conn)
+        self.mpy._mpy_comm = Mock()
+        # wipe orchestrates ls/delete/machine_reset; stub them to verify flow
+        self.mpy.ls = Mock(return_value=[])
+        self.mpy.delete = Mock()
+        self.mpy.machine_reset = Mock(return_value=True)
+
+    def test_wipe_deletes_all_root_entries(self):
+        """wipe deletes every root entry using an absolute path"""
+        self.mpy.ls.return_value = [('lib', None), ('boot.py', 42)]
+        self.mpy.wipe()
+        self.mpy.ls.assert_called_once_with('/')
+        self.mpy.delete.assert_any_call('/lib')
+        self.mpy.delete.assert_any_call('/boot.py')
+        self.assertEqual(self.mpy.delete.call_count, 2)
+
+    def test_wipe_machine_resets_with_args(self):
+        """wipe forwards reconnect/timeout to machine_reset"""
+        result = self.mpy.wipe(reconnect=True, timeout=5)
+        self.mpy.machine_reset.assert_called_once_with(
+            reconnect=True, timeout=5)
+        self.assertTrue(result)
+
+    def test_wipe_empty_filesystem_still_resets(self):
+        """wipe on empty FS deletes nothing but still resets"""
+        self.mpy.machine_reset.return_value = False
+        result = self.mpy.wipe(reconnect=False)
+        self.mpy.delete.assert_not_called()
+        self.mpy.machine_reset.assert_called_once_with(
+            reconnect=False, timeout=None)
+        self.assertFalse(result)
+
+    def test_wipe_invokes_on_delete_callback(self):
+        """on_delete is called with each path before deletion"""
+        self.mpy.ls.return_value = [('a.py', 1), ('b.py', 2)]
+        seen = []
+        self.mpy.wipe(on_delete=seen.append)
+        self.assertEqual(seen, ['/a.py', '/b.py'])
+
+    def test_wipe_deletes_before_reset(self):
+        """all deletes happen before the machine reset"""
+        calls = []
+        self.mpy.ls.return_value = [('x', 1)]
+        self.mpy.delete.side_effect = lambda p: calls.append(('del', p))
+        self.mpy.machine_reset.side_effect = (
+            lambda **k: calls.append(('reset',)) or True)
+        self.mpy.wipe()
+        self.assertEqual(calls, [('del', '/x'), ('reset',)])
+
+
 class TestExecSubmitOnly(unittest.TestCase):
     """Tests for exec() and exec_raw_paste() with timeout=0 (submit only)"""