Point the README and the command docs at plugin packages

Loading a command by path is for local development; a package is how a
command is distributed. The README's summary of what extends MVT now
names plugin packages and nothing else, and the section on loading a
command file says what it is for: keeping a command being written
loadable without reinstalling its package after every change.

README.md

@@ -58,9 +58,7 @@ For alternative installation options and known issues, please refer to the [docu
 
 ## Usage
 
-MVT provides three commands: `mvt-ios` and `mvt-android` analyse acquisitions from devices of that platform, and `mvt` hosts what belongs to neither: `version`, `completion`, `plugins` and `download-iocs` (`version` and `download-iocs` remain available on the platform commands for now). Running `mvt` on its own shows the installed version, update notices and the available commands. [Check out the documentation to learn how to use them!](https://docs.mvt.re/)
-
-Pass `--verbose` to any of the three commands, before the command name (`mvt-ios --verbose check-backup ...`), for debug output. The `--verbose` option the `check-*` commands accept after their name still works but is kept for compatibility only and will be removed in a future release.
+MVT provides three commands: `mvt-ios` and `mvt-android` analyse acquisitions from devices of that platform, and `mvt` hosts what belongs to neither: `version`, `completion` and `download-iocs` (`version` and `download-iocs` remain available on the platform commands for now). Running `mvt` on its own shows the installed version, update notices and the available commands. [Check out the documentation to learn how to use them!](https://docs.mvt.re/)
 
 ### Shell completion
 

docs/android/intrusion_logs.md

@@ -58,7 +58,7 @@ mvt-android check-intrusion-logs --output /path/to/results/ /path/to/intrusion-l
 | `-l, --list-modules` | List the available intrusion-log modules and exit. |
 | `-m, --module NAME` | Run a single module (e.g. `DnsEvent`) instead of all of them. |
 | `-t, --timezone TZ` | IANA timezone name for the device (e.g. `Europe/Paris`). When set, event timestamps are converted to the device's local time instead of UTC. |
-| `-v, --verbose` | Verbose logging. Kept for compatibility and to be removed in a future release: pass `--verbose` to `mvt-android` itself instead. |
+| `-v, --verbose` | Verbose logging. |
 
 ## Modules
 

docs/development/custom_commands.md

@@ -29,10 +29,6 @@ def summarize(path):
     click.echo(f"Summarizing {path}")
 ```
 
-Log through `get_plugin_logger(__name__)` from `mvt.plugin`. Records logged
-through `logging.getLogger(__name__)` do not reach `command.log`, and MVT's
-console handler does not show them.
-
 Register the object in the package's `pyproject.toml`. The entry-point name is
 the command users invoke:
 
@@ -64,8 +60,7 @@ pipx inject mvt my-mvt-plugin
 ```
 
 When MVT is installed in an active virtual environment, install the plugin with
-`pip` in that environment. `mvt plugins list` shows the installed packages and
-the commands they add, see [Managing Plugins](plugins.md).
+`pip` in that environment.
 
 Command packages that need their own settings, such as an API key, should store
 them in a namespaced [plugin configuration file](plugin_configuration.md)
@@ -73,7 +68,11 @@ rather than in MVT's own `config.yaml`.
 
 ### Commands on `mvt`
 
-A MVT plugin command can also add sub-commands to the base `mvt` command. This can be used for commands which are not tied to a particular forensic platform:
+The `mvt` command hosts what belongs to neither platform: `version`,
+`completion` and `download-iocs`. A plugin command which is not about the
+acquisition of one platform, such as one which configures the plugin or
+synchronizes the indicators it uses, belongs there too, in the
+`mvt.cli_plugins` group:
 
 ```toml
 [project.entry-points."mvt.cli_plugins"]
@@ -125,64 +124,6 @@ export MVT_IOS_CUSTOM_COMMANDS=./ios_commands
 export MVT_ANDROID_CUSTOM_COMMANDS=./android_commands
 ```
 
-## Building a Module-Running Command
-
-A command which runs forensic modules over an acquisition subclasses `Command`.
-`Command` creates the output folder and writes `command.log`. It orders the
-modules, resolves their dependencies and runs them. It writes the result files,
-`alerts.json` and `info.json`. The subclass sets `platform`, `name` and
-`modules`:
-
-```python
-from mvt.plugin import Command, MVTModule, convert_unix_to_iso, get_plugin_logger
-
-log = get_plugin_logger(__name__)
-
-
-class APKManifest(MVTModule):
-    supported_commands = (("android", "check-apks"),)
-
-    def run(self):
-        self.results = [{"checked_at": convert_unix_to_iso(0)}]
-
-
-class CmdCheckAPKs(Command):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.platform = "android"
-        self.name = "check-apks"
-        self.modules = [APKManifest]
-```
-
-`platform` and `name` are the pair the modules declare in
-`supported_commands`. `modules` lists the module classes the command runs,
-imported directly. A command which runs modules of another plugin depends on
-that package in `pyproject.toml` and imports them the same way. `init()`,
-`module_init(module)` and `finish()` are optional hooks. `run()` calls them
-before the run, before each module and after the run.
-
-Wrap the command in a Click command with an `--output` option. Run it, then
-print the alert summary:
-
-```python
-import click
-
-
-@click.command("check-apks")
-@click.option("--output", "-o", type=click.Path(exists=False))
-@click.argument("TARGET_PATH", type=click.Path(exists=True))
-def cli(output, target_path):
-    cmd = CmdCheckAPKs(target_path=target_path, results_path=output)
-    log.info("Checking APK files at path: %s", target_path)
-    cmd.run()
-    cmd.show_alerts_brief()
-```
-
-The `--verbose` option of `mvt`, `mvt-ios` and `mvt-android` applies to the
-command. The command defines no `--verbose` option of its own. The pair a
-plugin command adds is not listed anywhere in MVT. Name it in the plugin's
-README.
-
 ## Naming and Errors
 
 Built-in MVT commands cannot be replaced. External command names must also be

docs/development/index.md

@@ -48,21 +48,51 @@ configuration problem: the command logs a warning and runs no modules at all.
 
 ## Custom modules
 
-MVT's module-running `check-*` commands can run forensic modules which are not
-part of MVT. Custom modules are distributed as plugin packages. A Python
-package installed next to MVT registers its modules through an entry point.
-The modules then load automatically in every command they support, see
-[Installed module packages](#installed-module-packages). `mvt plugins list`
-shows the installed packages and where each one was installed from.
+Module-running `check-*` commands can load custom modules from Python files that
+are not installed as part of MVT. Load one file with:
 
-MVT can also load module files by path, with `--load-module` and
-`MVT_CUSTOM_MODULES`, see
-[Developing modules locally](#developing-modules-locally). This can be used
-while writing a module. Use a Python package to distribute one.
+```bash
+mvt-ios check-backup --load-module ./example_module.py --output ./out ./backup
+```
 
-A custom module declares in `supported_commands` the platform and command
-pairs it runs in. A module with empty `supported_commands` does not run and
-MVT logs a warning. The nine pairs are:
+You can also load a folder. MVT loads non-hidden top-level `*.py` files in
+sorted order and skips `__init__.py`:
+
+```bash
+mvt-ios check-fs --load-module ./custom_modules ./filesystem-dump
+```
+
+Set `MVT_CUSTOM_MODULES` to load a folder for every module-running command. This
+folder is loaded before any `--load-module` path:
+
+```bash
+MVT_CUSTOM_MODULES=./custom_modules mvt-android check-bugreport ./bugreport.zip
+```
+
+Custom modules are normal `MVTModule` subclasses:
+
+```python
+from mvt.common.module import MVTModule
+
+
+class ExampleCustomModule(MVTModule):
+    supported_commands = (("ios", "check-backup"), ("ios", "check-fs"))
+    slug = "example_custom_module"
+
+    def run(self):
+        self.results = [{"message": "custom module ran"}]
+
+    def check_indicators(self):
+        pass
+
+    def serialize(self, result):
+        return None
+```
+
+Use `supported_commands` to declare the platform/command pairs a module
+supports. Empty `supported_commands` means the module will not run and MVT logs
+a warning. This explicit declaration is required for every command. Supported
+pairs are:
 
 ```python
 ("ios", "check-backup")
@@ -76,88 +106,13 @@ MVT logs a warning. The nine pairs are:
 ("android", "check-iocs")
 ```
 
-`check-iocs` re-checks stored results rather than an acquisition. It matches
-every `<slug>.json` file in the results folder to the module with that slug.
-It then runs that module's `check_indicators()` again. A module which
-implements `check_indicators()` is included in `check-iocs` for its platform.
-It does not need to declare the `check-iocs` pair.
-
-### Writing a module
-
-A module subclasses `MVTModule` or one of the base classes below and
-implements `run()`. `check_indicators()` and `serialize()` are optional. The
-first matches results against IOCs or detections. The second returns timeline
-records.
+Custom modules can depend on existing MVT module classes. Dependencies are
+resolved with the same ordering logic as built-in modules, and custom modules
+are appended after built-ins before ordering:
 
 ```python
-from mvt.plugin import IOSExtraction, convert_unix_to_iso
-
-
-class ExampleCustomModule(IOSExtraction):
-    supported_commands = (
-        ("ios", "check-backup"),
-        ("ios", "check-fs"),
-    )
-    slug = "example_custom_module"
-
-    def run(self):
-        self.results = [{"checked_at": convert_unix_to_iso(0)}]
-
-    def check_indicators(self):
-        pass
-
-    def serialize(self, result):
-        return None
-```
-
-The base classes are:
-
-- `MVTModule`: the base of every module. It provides `self.results`,
-  `self.alertstore`, `self.log`, `self.indicators` and
-  `get_dependency_results()`. Subclass it directly for a module which reads
-  only the results of other modules.
-- `IOSExtraction`: `("ios", "check-backup")` and `("ios", "check-fs")`. Adds
-  `_find_ios_database()`, which locates a module's database in a backup or in
-  a filesystem dump and repairs it if it is malformed. Adds
-  `_get_backup_files_from_manifest()`, `_get_backup_file_from_id()` and
-  `_get_fs_files_from_patterns()`. Adds `_open_sqlite_db()`, which opens a
-  database read-only.
-- `SysdiagnoseExtraction`: `("ios", "check-sysdiagnose")`. MVT extracts the
-  archive and calls `from_sysdiagnose_folder()` before `run()`. The module
-  reads files with `_get_files_by_pattern()` and `_get_file_content()`.
-  `ips_files` lists the crash reports. See
-  [Check an iOS Sysdiagnose](../ios/sysdiagnose.md).
-- `AndroidQFModule`: `("android", "check-androidqf")`. MVT calls `from_dir()`
-  or `from_zip()` with the file list of the acquisition. The module reads
-  files with `_get_files_by_pattern()` and `_get_file_content()`.
-  `_get_device_timezone()` returns the device timezone.
-- `AndroidBackupModule`: `("android", "check-backup")`. MVT calls `from_dir()`
-  or `from_ab()`. The module reads files with `_get_files_by_pattern()` and
-  `_get_file_content()`.
-- `BugReportModule`: `("android", "check-bugreport")`. MVT calls `from_dir()`
-  or `from_zip()`. The module reads files with `_get_files_by_pattern()`,
-  `_get_files_by_patterns()` and `_get_file_content()`.
-  `_get_dumpstate_file()` returns the dumpstate file, and
-  `_get_file_modification_time()` the modification time of a file.
-
-The underscore-named helpers are internal to the base classes. Plugin modules
-can call them. Their names and signatures can change between releases. Read
-the base class in `src/mvt/ios/modules` or `src/mvt/android/modules` before
-relying on one.
-
-### Depending on a built-in module
-
-A module which post-processes records generated by one or more built-in MVT
-modules must declare the source modules in `dependencies`. It reads their
-results with `get_dependency_results()`. Import the class from its family
-package: `mvt.ios.modules.backup`, `mvt.ios.modules.fs`,
-`mvt.ios.modules.mixed`, `mvt.android.modules.androidqf`,
-`mvt.android.modules.backup`, `mvt.android.modules.bugreport` or
-`mvt.android.modules.intrusion_logs`.
-
-```python
-from mvt.ios.modules.backup import Manifest
-from mvt.plugin import MVTModule
+from mvt.common.module import MVTModule
+from mvt.ios.modules.backup.manifest import Manifest
 
 
 class DependentCustomModule(MVTModule):
@@ -169,85 +124,6 @@ class DependentCustomModule(MVTModule):
         self.results = [{"manifest_entries": len(manifest_results)}]
 ```
 
-Dependencies are ordered as for the built-in modules, with custom modules
-appended after the built-ins, see [Module dependencies](#module-dependencies).
-A dependency has to run in every command the module supports. Where it does
-not, MVT skips the module with a warning.
-
-`get_dependency_results()` returns the plain dictionaries the module produced.
-They are the same records it writes to `<slug>.json`. Typed results per module
-are planned.
-
-### Replacing a built-in module
-
-A custom module which extends a built-in one runs alongside it, and when the
-two share a slug they write to the same results file. MVT warns about that
-collision, naming both modules, where each came from and the file the later one
-overwrites, but it runs them both. Set `replaces` to the class the module
-supersedes to take that module's place instead: when both are available to a
-command, the named module is dropped from the run.
-
-```python
-from mvt.ios.modules.backup import Manifest as BuiltinManifest
-
-
-class Manifest(BuiltinManifest):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = BuiltinManifest
-```
-
-Keeping the class name of the replaced module, as above, keeps the name
-`--module` selects the module by and the slug its results file is named after.
-A replacement with a different class name writes to a file named after its own
-slug, unless it sets `slug` to the slug of the module it replaces, and
-`--module` still selects it by the name of the replaced module, which MVT logs.
-Taking over the slug of a replaced module is not a collision and is not warned
-about, because that module is no longer part of the run.
-
-Modules which depend on the replaced module receive the replacement instead, so
-`get_dependency_results(BuiltinManifest)` returns the replacement's results. A
-module must not depend on the module it replaces: that module does not run, so
-the replacement has to produce the data itself, and MVT logs a warning when a
-module declares both.
-
-A replacement takes on the obligations of the module it replaces. If it
-declares a dependency the command does not provide, it is skipped like any
-other module with an unavailable dependency, and the module it replaced stays
-out of the run: neither of them produces results, and the modules depending on
-the replaced module are skipped as well.
-
-Subclassing the replaced module is not required, but a replacement which is not
-a subclass is logged with a warning, because its results may not be what the
-modules depending on the replaced module expect. Naming a module the command
-does not run has no effect, and modules which replace each other in a cycle all
-keep running and replace nothing. Every applied substitution is logged, so it
-is recorded in `command.log` when the command runs with an `--output` folder.
-
-Every command resolves replacements on its own. `check-iocs` matches stored
-results files against the slugs of the modules available for that command. A
-replacement which subclasses the module it replaces inherits its
-`check_indicators()`. It is then part of `check-iocs` for its platform and
-re-checks the results file named after its slug. A replacement with no
-`check_indicators()` is not part of `check-iocs`. The built-in module it
-replaced re-checks the file. `check-iocs` matches `--module` on the class name
-only. Pass a differently named replacement's own name there, not the name of
-the module it replaces.
-
-### Importing from MVT
-
-Import from `mvt.plugin` if it has what you need. The names it exports are
-kept working on a best-effort basis. A change to one of them is announced in
-the release notes. Anything else in `mvt` can be imported too, but may change
-between releases without notice. The plugin interface is best effort.
-
-`mvt.plugin` exports the base classes above and `Command`, `Alert` and
-`AlertLevel`, the result types, `DatabaseNotFoundError` and
-`DatabaseCorruptedError`, the timestamp converters, the settings API of
-[Plugin Configuration](plugin_configuration.md), MVT's own `settings`,
-`get_plugin_logger()` and `MVT_VERSION`. `src/mvt/plugin.py` holds the list.
-Read MVT's `settings` for values such as `NETWORK_ACCESS_ALLOWED` and
-`NETWORK_TIMEOUT`. Plugin values go in the plugin's own settings file.
-
 ## Installed module packages
 
 Python packages can register modules so they load automatically in every
@@ -257,14 +133,14 @@ the package's `pyproject.toml`:
 
 ```toml
 [project.entry-points."mvt.modules"]
-mvt-plugin-example-org = "mvt_plugin_example_org:get_modules"
+mvt-plugin-amnesty-custom = "mvt_plugin_amnesty_custom:get_modules"
 ```
 
 The entry point must resolve to an iterable of `MVTModule` subclasses, or to
 a callable returning one:
 
 ```python
-from mvt.plugin import MVTModule
+from mvt.common.module import MVTModule
 
 
 class PackagedModule(MVTModule):
@@ -278,10 +154,6 @@ def get_modules() -> list[type[MVTModule]]:
     return [PackagedModule]
 ```
 
-`get_modules()` is the package's module list, written by hand. A package which
-keeps its modules in separate files imports each class there and lists it. A
-module missing from the list does not load.
-
 Installed modules follow the same rules as other custom modules: each module
 must declare `supported_commands`, and dependencies are resolved with the
 standard ordering logic. A broken entry point is skipped with a warning and
@@ -292,7 +164,7 @@ from sources you trust.
 For a `pipx` installation of MVT, inject the package into MVT's environment:
 
 ```bash
-pipx inject mvt mvt-plugin-example-org
+pipx inject mvt mvt-plugin-amnesty-custom
 ```
 
 Module packages that need their own settings, such as an API key, should store
@@ -303,9 +175,9 @@ rather than in MVT's own `config.yaml`.
 
 Name module packages `mvt-plugin-<name>` (import package `mvt_plugin_<name>`),
 and include the name of the publishing organization or author so packages from
-different groups do not collide: for example, an organisation's custom modules
-would be distributed as `mvt-plugin-example-org` with the import package
-`mvt_plugin_example_org`.
+different groups do not collide: for example, Amnesty International's custom
+modules would be distributed as `mvt-plugin-amnesty-custom` with the import
+package `mvt_plugin_amnesty_custom`.
 
 The prefix makes module packages easy to find on PyPI and keeps their import
 names from clashing with unrelated Python packages. It is a convention, not a
@@ -324,42 +196,11 @@ came from. MVT's own modules log under their dotted path (for example
 MVT's internal logger tree:
 
 - Installed packages log under `mvt.ext.<package>`, with the `mvt_plugin_`
-  prefix stripped: modules in `mvt_plugin_example_org` log as
-  `mvt.ext.example_org.*`.
+  prefix stripped: modules in `mvt_plugin_amnesty_custom` log as
+  `mvt.ext.amnesty_custom.*`.
 - Files loaded with `--load-module` or `MVT_CUSTOM_MODULES` log as
   `mvt.ext.<file name>`.
 
-Outside a module class, for example in a custom command line handler, log
-through `get_plugin_logger(__name__)`. It returns a logger in the same
-namespace.
-
-## Developing modules locally
-
-While a module is being written, load it from its file. `--load-module` takes a
-Python file, or a folder of them, on every module-running command, and can be
-repeated:
-
-```bash
-mvt-ios check-backup --load-module ./example_module.py --output ./out ./backup
-```
-
-For a folder, MVT loads its non-hidden top-level `*.py` files in sorted order
-and skips `__init__.py`. `MVT_CUSTOM_MODULES` names a folder to load on every
-module-running command, before any `--load-module` path:
-
-```bash
-MVT_CUSTOM_MODULES=./custom_modules mvt-android check-bugreport ./bugreport.zip
-```
-
-Files loaded this way follow the same rules as packaged modules.
-`--list-modules` reports them with the SHA-256 hash of the file in place of a
-version. An editable install of the package (`pip install -e .`) also works:
-the modules load through the entry point, and `mvt plugins list` shows the
-package with the `local` origin.
-
-Loading by path is for development. Move a module into a package once it
-works.
-
 ## Auditing loaded modules
 
 Because installed module packages load automatically, MVT records where every
@@ -373,9 +214,6 @@ module came from:
 - When a command runs with an `--output` folder, the `command.log` file
   records one line per module source with the source's version or hash and
   the list of modules loaded from it.
-- `mvt plugins list` lists the installed packages, where each of them
-  was installed from and how many modules it contributes, see
-  [Managing Plugins](plugins.md).
 
 ## Profiling
 

docs/development/plugin_configuration.md

@@ -24,7 +24,8 @@ configuration:
 
 The exact parent folder follows the platform convention used for MVT's
 `config.yaml` (for example `~/Library/Application Support/mvt` on macOS). Use
-`plugin_config_path()` from `mvt.plugin` instead of building the path by hand.
+`mvt.common.plugin_config.plugin_config_path()` instead of building the path by
+hand.
 
 Plugin names must be lowercase and may only contain letters, digits and dashes,
 matching the `mvt-plugin-<name>` package naming convention. MVT creates the
@@ -37,8 +38,9 @@ leaves a partially written settings file behind.
 
 Everything else a plugin keeps on disk, such as a cache, a downloaded artifact
 or synchronization state, belongs in the folder returned by the `data_folder()`
-class method of the plugin's settings class, or by `plugin_data_folder()` from
-`mvt.plugin`, called with the plugin name if the plugin has no settings class:
+class method of the plugin's settings class, or by
+`mvt.common.plugin_config.plugin_data_folder()` called with the plugin name if
+the plugin has no settings class:
 
 ```
 ~/.local/share/mvt/plugin-data/<plugin name>/                # Linux
@@ -74,7 +76,7 @@ defaults:
 ```python
 from typing import Optional
 
-from mvt.plugin import MVTPluginSettings
+from mvt.common.plugin_config import MVTPluginSettings
 
 
 class ExamplePluginSettings(MVTPluginSettings):
@@ -92,15 +94,12 @@ from datetime import datetime, timezone
 
 import click
 
-from mvt.plugin import plugin_env_prefix
-
 
 def sync():
     settings = ExamplePluginSettings.load()
     if not settings.API_KEY:
-        prefix = plugin_env_prefix(settings.plugin_name)
         raise click.ClickException(
-            f"No API key configured. Set {prefix}API_KEY or "
+            "No API key configured. Set MVT_PLUGIN_EXAMPLE_PLUGIN_API_KEY or "
             "run 'example-plugin configure'."
         )
 
@@ -108,9 +107,6 @@ def sync():
     settings.save()
 ```
 
-The message builds the variable name with `plugin_env_prefix()`, see
-[Environment Variables](#environment-variables).
-
 A missing settings file is not an error: the plugin then runs on the field
 defaults and on whatever the environment provides. `save()` only persists the
 values that differ from the defaults, and it never touches MVT's `config.yaml`.
@@ -133,10 +129,6 @@ export MVT_PLUGIN_EXAMPLE_PLUGIN_API_KEY=...
 export MVT_PLUGIN_EXAMPLE_PLUGIN_MAX_RESULTS=50
 ```
 
-Do not repeat the plugin name in a field name: a plugin named `example-scanner`
-with a `SCANNER_API_KEY` field asks the user for
-`MVT_PLUGIN_EXAMPLE_SCANNER_SCANNER_API_KEY`. Name the field `API_KEY`.
-
 Settings resolve in this order, from highest to lowest priority:
 
 1. Arguments passed to the settings class directly, such as

docs/development/plugins.md

@@ -1,116 +0,0 @@
-# Managing Plugins
-
-Plugin packages extend MVT with additional
-[forensic modules](index.md#custom-modules) and
-[CLI commands](custom_commands.md). Because installed packages load
-automatically, `mvt plugins` audits what is installed and checks whether
-updates are available. The command lives on `mvt` only, although the packages
-it lists extend `mvt-ios` and `mvt-android` too.
-
-## List Installed Plugins
-
-```bash
-mvt plugins list
-```
-
-```
-                        Installed MVT plugins
-┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━┓
-┃ Name                ┃ Version ┃ Origin       ┃ Modules ┃ Commands  ┃
-┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━┩
-│ mvt-plugin-example  │ 1.2.0   │ pypi         │       4 │ summarize │
-│ mvt-plugin-research │ 0.1.0   │ git+3f9a1c7d │       2 │ -         │
-│ mvt-plugin-local    │ 0.0.1   │ local        │       1 │ triage    │
-└─────────────────────┴─────────┴──────────────┴─────────┴───────────┘
-```
-
-The origin records where each package was installed from: `pypi` for a package
-installed from a package index, `git+<commit>` for a package installed directly
-from a repository, and `local` for a package installed from a local folder or
-archive rather than from an index, including an editable development install.
-The last two columns show how many forensic modules the package contributes and
-which CLI commands it adds.
-
-A plugin whose modules cannot be imported is listed with `error` in the
-`Modules` column rather than breaking the listing.
-
-## Check for Updates
-
-```bash
-mvt plugins check-updates
-```
-
-```
-Plugin updates available:
-  mvt-plugin-example  1.2.0 → 1.3.0
-    Upgrade with: pip install -U mvt-plugin-example
-
-MVT does not install plugin updates. Run the command above when you decide to
-upgrade.
-```
-
-Packages installed from a package index are compared against the latest release
-published for them. A package which was never published, for example a plugin
-distributed only within an organization, is skipped silently.
-
-!!! note
-
-    Packages shown with the `pypi` origin are compared against
-    [PyPI](https://pypi.org), whichever index they were installed from. A
-    plugin installed from a private index under a name which also exists on
-    PyPI is therefore compared against the unrelated public package of that
-    name. Give plugins published to a private index a name which is not taken
-    on PyPI, and treat an unexpected update suggestion as a reason to check
-    where the package would come from.
-
-!!! warning
-
-    MVT never installs or upgrades a plugin itself, it only prints the command
-    which does. Upgrading a plugin in the middle of an investigation changes
-    the modules producing the results, and a plugin runs as trusted code inside
-    the MVT process, so pulling in a new version is a decision for the analyst
-    to make deliberately and not a side effect of running a check.
-
-## Automatic Update Checks
-
-MVT also reports available plugin updates in the banner printed when a command
-starts:
-
-```
-        MVT - Mobile Verification Toolkit
-
-        https://mvt.re
-        Version: 2026.7.29
-
-        Plugin updates available:
-          mvt-plugin-example  1.2.0 → 1.3.0   (pip install -U mvt-plugin-example)
-```
-
-This check runs at most once every 12 hours. In between checks MVT prints the
-findings of the latest check without contacting anything, so a plugin update
-stays visible without a lookup on every command. The
-`mvt plugins check-updates` command checks immediately, regardless of when the
-last check happened.
-
-The automatic check is skipped when the `--disable-update-check` option is
-used, when `NETWORK_ACCESS_ALLOWED` is disabled in the MVT configuration, and
-when no plugins are installed.
-
-## Plugins Installed From a Repository
-
-A plugin installed with `pip install "mvt-plugin-example @ git+<url>"` is
-checked by asking the remote repository which commit the installed revision
-points at now. MVT runs git and ssh in batch mode, so a repository which needs
-credentials MVT does not already have fails the check instead of prompting for
-them. The check is skipped silently when git is not available, when the
-repository cannot be reached, and when access to it is denied.
-
-How the plugin was installed decides what an update means:
-
-- A plugin installed from a branch is reported as outdated when the branch has
-  moved past the installed commit.
-- A plugin installed from a specific commit or a tag is pinned. It is never
-  reported as outdated, however far the branch it came from moves on.
-
-Pinning a plugin to a commit or a tag is therefore the way to keep the modules
-used across an investigation stable.

docs/ios/sysdiagnose.md

@@ -1,32 +1,30 @@
 # Check an iOS Sysdiagnose
 
 `mvt-ios check-sysdiagnose` prepares an iOS sysdiagnose archive for analysis by
-custom MVT modules. MVT does not include built-in sysdiagnose modules. The
-command runs the modules of the installed
-[plugin packages](../development/index.md#installed-module-packages) which
-declare support for it. Install at least one such package first.
+custom MVT modules. MVT does not include built-in sysdiagnose modules. You must
+load at least one custom module that explicitly supports this command.
 
 The command accepts either an extracted sysdiagnose directory or the original
 gzip-compressed tar archive.
 
 ```bash
-mvt-ios check-sysdiagnose --output ./results \
+mvt-ios check-sysdiagnose \
+    --load-module ./sysdiagnose_modules.py \
+    --output ./results \
     ./sysdiagnose_2024.01.02_03-04-05+0200.tar.gz
 ```
 
 Use `--hashes` to include hashes for analyzed files in `info.json`, and
-`--list-modules` to display the eligible modules without running them.
+`--list-modules` to display the eligible custom modules without running them.
 
 ## Writing a custom module
 
-Extend `SysdiagnoseExtraction` from `mvt.plugin`, see
-[Writing a module](../development/index.md#writing-a-module). The module reads
-the archive the same way whether MVT was given a folder or a tar archive. It
-declares the command in `supported_commands`. While writing one,
-[load it from its file](../development/index.md#developing-modules-locally).
+Extend `SysdiagnoseExtraction` to access the archive contents consistently for
+both directory and tar inputs. Each module must declare the command explicitly
+in `supported_commands`.
 
 ```python
-from mvt.plugin import SysdiagnoseExtraction
+from mvt.ios.modules.sysdiagnose import SysdiagnoseExtraction
 
 
 class ExampleSysdiagnoseModule(SysdiagnoseExtraction):
@@ -46,9 +44,7 @@ class ExampleSysdiagnoseModule(SysdiagnoseExtraction):
         return None
 ```
 
-MVT extracts a tar archive first. It calls `from_sysdiagnose_folder()` on each
-module before `run()`. `ips_files` lists the IPS crash reports.
-
-`_get_files_by_pattern()` and `_get_file_content()` are internal helpers of the
-base class. Use them to read the archive. Their names and signatures can change
-between releases. See `src/mvt/ios/modules/sysdiagnose/base.py`.
+The base class provides `from_sysdiagnose_folder()` and
+`from_sysdiagnose_tar()` setup hooks, as well as protected file lookup, file
+reading, and timezone extraction helpers. IPS crash-report metadata is exposed
+on `ips_files`.

mkdocs.yml

@@ -53,5 +53,4 @@ nav:
         - Development Instructions: "development/index.md"
         - Custom CLI Commands: "development/custom_commands.md"
         - Plugin Configuration: "development/plugin_configuration.md"
-        - Managing Plugins: "development/plugins.md"
     - License: "license.md"

src/mvt/android/artifacts/tombstone_crashes.py

@@ -191,14 +191,9 @@ class TombstoneCrashArtifact(AndroidArtifact):
     def _load_key_value_line(
         self, line: str, key: str, destination_key: str, tombstone: dict
     ) -> bool:
-        # The caller matched the key as a bare prefix, so a longer word starting
-        # with it arrives here: `Caused by: …` inside an abort message reaches
-        # the `Cause` key. That is a different line, not a broken file — say so
-        # by declining it, and let the remaining keys have their turn. Raising
-        # here discarded the whole tombstone, crash and stack trace included.
-        line_key, separator, value = line.partition(":")
-        if not separator or line_key != key:
-            return False
+        line_key, value = line.split(":", 1)
+        if line_key != key:
+            raise ValueError(f"Expected key {key}, got {line_key}")
 
         value_clean = value.strip().strip("'")
         if destination_key == "uid":

src/mvt/android/cli.py

@@ -14,6 +14,7 @@ from mvt.common.cli_plugins import (
     load_cli_commands_option,
     register_cli_plugins,
 )
+from mvt.common.cmd_check_iocs import CmdCheckIOCS
 from mvt.common.help import (
     HELP_MSG_ANDROID_BACKUP_PASSWORD,
     HELP_MSG_CHECK_ADB_REMOVED,
@@ -35,16 +36,23 @@ from mvt.common.help import (
     HELP_MSG_OUTPUT,
     HELP_MSG_STIX2,
     HELP_MSG_VERBOSE,
-    HELP_MSG_VERBOSE_COMMAND,
     HELP_MSG_VERSION,
     HELP_MSG_VIRUS_TOTAL,
 )
+from mvt.common.logo import logo
+from mvt.common.module_loader import CustomModuleLoadError, load_custom_modules
+from mvt.common.updates import IndicatorsUpdates
 from mvt.common.utils import init_logging, set_verbose_logging
 
-# The commands import what they run only when they are invoked. This module is
-# imported at every start of mvt-android, including by shell completion on
-# every keystroke, so importing it must do no more than build the command tree:
-# the forensic modules, the backup parsers and the update checks stay out of it.
+from .cmd_check_androidqf import CmdAndroidCheckAndroidQF
+from .cmd_check_backup import CmdAndroidCheckBackup
+from .cmd_check_bugreport import CmdAndroidCheckBugreport
+from .cmd_check_intrusion_logs import CmdAndroidCheckIntrusionLogs
+from .modules.intrusion_logs import INTRUSION_LOGS_MODULES
+from .modules.androidqf import ANDROIDQF_MODULES
+from .modules.backup import BACKUP_MODULES
+from .modules.backup.helpers import cli_load_android_backup_password
+from .modules.bugreport import BUGREPORT_MODULES
 
 init_logging()
 log = logging.getLogger("mvt")
@@ -62,14 +70,7 @@ def _get_disable_flags(ctx):
     )
 
 
-def _get_verbose(ctx):
-    """Return whether --verbose was passed to the CLI itself."""
-    return bool(ctx.obj and ctx.obj.get("verbose", False))
-
-
 def _load_custom_modules(load_module):
-    from mvt.common.module_loader import CustomModuleLoadError, load_custom_modules
-
     try:
         return load_custom_modules(load_module)
     except CustomModuleLoadError as exc:
@@ -89,17 +90,11 @@ def _load_custom_modules(load_module):
     is_flag=True,
     help=HELP_MSG_DISABLE_INDICATOR_UPDATE_CHECK,
 )
-@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE)
 @click.pass_context
-def cli(ctx, disable_update_check, disable_indicator_update_check, verbose):
+def cli(ctx, disable_update_check, disable_indicator_update_check):
     ctx.ensure_object(dict)
     ctx.obj["disable_version_check"] = disable_update_check
     ctx.obj["disable_indicator_check"] = disable_indicator_update_check
-    ctx.obj["verbose"] = verbose
-    set_verbose_logging(verbose)
-
-    from mvt.common.logo import logo
-
     logo(
         disable_version_check=disable_update_check,
         disable_indicator_check=disable_indicator_update_check,
@@ -150,7 +145,7 @@ def check_adb(ctx):
     default=[],
     help=HELP_MSG_LOAD_MODULE,
 )
-@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE_COMMAND)
+@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE)
 @click.argument("BUGREPORT_PATH", type=click.Path(exists=True))
 @click.pass_context
 def check_bugreport(
@@ -163,9 +158,7 @@ def check_bugreport(
     verbose,
     bugreport_path,
 ):
-    from .cmd_check_bugreport import CmdAndroidCheckBugreport
-
-    set_verbose_logging(verbose or _get_verbose(ctx))
+    set_verbose_logging(verbose)
     custom_modules = _load_custom_modules(load_module)
     # Always generate hashes as bug reports are small.
     cmd = CmdAndroidCheckBugreport(
@@ -220,7 +213,7 @@ def check_bugreport(
 )
 @click.option("--non-interactive", "-n", is_flag=True, help=HELP_MSG_NONINTERACTIVE)
 @click.option("--backup-password", "-p", help=HELP_MSG_ANDROID_BACKUP_PASSWORD)
-@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE_COMMAND)
+@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE)
 @click.argument("BACKUP_PATH", type=click.Path(exists=True))
 @click.pass_context
 def check_backup(
@@ -234,10 +227,7 @@ def check_backup(
     verbose,
     backup_path,
 ):
-    from .cmd_check_backup import CmdAndroidCheckBackup
-    from .modules.backup.helpers import cli_load_android_backup_password
-
-    set_verbose_logging(verbose or _get_verbose(ctx))
+    set_verbose_logging(verbose)
     custom_modules = _load_custom_modules(load_module)
 
     # Always generate hashes as backups are generally small.
@@ -297,7 +287,7 @@ def check_backup(
 )
 @click.option("--non-interactive", "-n", is_flag=True, help=HELP_MSG_NONINTERACTIVE)
 @click.option("--backup-password", "-p", help=HELP_MSG_ANDROID_BACKUP_PASSWORD)
-@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE_COMMAND)
+@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE)
 @click.argument("ANDROIDQF_PATH", type=click.Path(exists=True))
 @click.pass_context
 def check_androidqf(
@@ -315,10 +305,7 @@ def check_androidqf(
     verbose,
     androidqf_path,
 ):
-    from .cmd_check_androidqf import CmdAndroidCheckAndroidQF
-    from .modules.backup.helpers import cli_load_android_backup_password
-
-    set_verbose_logging(verbose or _get_verbose(ctx))
+    set_verbose_logging(verbose)
     custom_modules = _load_custom_modules(load_module)
 
     cmd = CmdAndroidCheckAndroidQF(
@@ -386,7 +373,7 @@ def check_androidqf(
         "time instead of UTC."
     ),
 )
-@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE_COMMAND)
+@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE)
 @click.argument("LOGS_PATH", type=click.Path(exists=True))
 @click.pass_context
 def check_intrusion_logs(
@@ -400,9 +387,7 @@ def check_intrusion_logs(
     verbose,
     logs_path,
 ):
-    from .cmd_check_intrusion_logs import CmdAndroidCheckIntrusionLogs
-
-    set_verbose_logging(verbose or _get_verbose(ctx))
+    set_verbose_logging(verbose)
     custom_modules = _load_custom_modules(load_module)
 
     module_options = {}
@@ -455,10 +440,6 @@ def check_intrusion_logs(
 @click.argument("FOLDER", type=click.Path(exists=True))
 @click.pass_context
 def check_iocs(ctx, iocs, list_modules, module, load_module, folder):
-    from mvt.common.cmd_check_iocs import CmdCheckIOCS
-
-    from .command_modules import ANDROID_CHECK_IOCS_MODULES
-
     custom_modules = _load_custom_modules(load_module)
     cmd = CmdCheckIOCS(
         target_path=folder,
@@ -469,7 +450,9 @@ def check_iocs(ctx, iocs, list_modules, module, load_module, folder):
         custom_modules=custom_modules,
         platform="android",
     )
-    cmd.modules = ANDROID_CHECK_IOCS_MODULES
+    cmd.modules = (
+        BACKUP_MODULES + BUGREPORT_MODULES + ANDROIDQF_MODULES + INTRUSION_LOGS_MODULES
+    )
 
     if list_modules:
         cmd.list_modules()
@@ -485,8 +468,6 @@ def check_iocs(ctx, iocs, list_modules, module, load_module, folder):
 # ==============================================================================
 @cli.command("download-iocs", context_settings=CONTEXT_SETTINGS, help=HELP_MSG_STIX2)
 def download_indicators():
-    from mvt.common.updates import IndicatorsUpdates
-
     ioc_updates = IndicatorsUpdates()
     ioc_updates.update()
 

src/mvt/android/cmd_check_androidqf.py

@@ -292,7 +292,9 @@ class CmdAndroidCheckAndroidQF(Command):
         try:
             cmd.from_ab(backup)
         except InvalidAndroidBackup as exc:
-            self.log.warning("Skipping backup modules: %s", exc)
+            self.log.warning(
+                "Skipping backup modules as backup.ab is malformed: %s", exc
+            )
             return False
 
         cmd.run()

src/mvt/android/cmd_check_backup.py

@@ -87,15 +87,11 @@ class CmdAndroidCheckBackup(Command):
         if header["encryption"] != "none":
             password = prompt_or_load_android_backup_password(log, self.module_options)
             if not password:
-                if self.sub_command:
-                    raise InvalidAndroidBackup("No backup password provided")
                 log.critical("No backup password provided.")
                 sys.exit(1)
         try:
             tardata = parse_backup_file(ab_file_bytes, password=password)
         except InvalidBackupPassword:
-            if self.sub_command:
-                raise InvalidAndroidBackup("Invalid backup password")
             log.critical("Invalid backup password")
             sys.exit(1)
         except AndroidBackupParsingError as exc:

src/mvt/android/command_modules.py

@@ -1,23 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2026 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-
-"""Module lists an mvt-android command composes from more than one family.
-
-Commands whose modules are one family read that family directly. check-iocs
-re-checks stored results, so it has to know every module that could have
-written one, and both the CLI and any other code needing that answer share
-the list from here rather than each concatenating their own.
-"""
-
-from mvt.common.module import MVTModule
-
-from .modules.androidqf import ANDROIDQF_MODULES
-from .modules.backup import BACKUP_MODULES
-from .modules.bugreport import BUGREPORT_MODULES
-from .modules.intrusion_logs import INTRUSION_LOGS_MODULES
-
-ANDROID_CHECK_IOCS_MODULES: list[type[MVTModule]] = (
-    BACKUP_MODULES + BUGREPORT_MODULES + ANDROIDQF_MODULES + INTRUSION_LOGS_MODULES
-)

src/mvt/cli.py

@@ -11,18 +11,16 @@ from mvt.common.cli_plugins import (
     load_cli_commands_option,
     register_cli_plugins,
 )
-from mvt.common.cmd_plugins import plugins
 from mvt.common.completion import completion
 from mvt.common.help import (
     HELP_MSG_DISABLE_INDICATOR_UPDATE_CHECK,
     HELP_MSG_DISABLE_UPDATE_CHECK,
     HELP_MSG_STIX2,
-    HELP_MSG_VERBOSE,
     HELP_MSG_VERSION,
 )
 from mvt.common.logo import logo
 from mvt.common.updates import IndicatorsUpdates
-from mvt.common.utils import init_logging, set_verbose_logging
+from mvt.common.utils import init_logging
 
 init_logging()
 
@@ -42,19 +40,18 @@ CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
     is_flag=True,
     help=HELP_MSG_DISABLE_INDICATOR_UPDATE_CHECK,
 )
-@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE)
 @click.pass_context
-def cli(ctx, disable_update_check, disable_indicator_update_check, verbose):
+def cli(ctx, disable_update_check, disable_indicator_update_check):
     """Mobile Verification Toolkit.
 
-    The 'mvt-ios' and 'mvt-android' CLI commands are used to perform
-    forensic analysis on IOS and Android devices.
+    mvt-ios and mvt-android run the forensic analysis of an acquisition: each
+    provides the check-* commands of its platform. This command hosts what
+    belongs to neither platform; run it without a command to see the installed
+    version and the list of what it offers.
     """
     ctx.ensure_object(dict)
     ctx.obj["disable_version_check"] = disable_update_check
     ctx.obj["disable_indicator_check"] = disable_indicator_update_check
-    ctx.obj["verbose"] = verbose
-    set_verbose_logging(verbose)
     if ctx.invoked_subcommand != "completion":
         logo(
             disable_version_check=disable_update_check,
@@ -87,11 +84,6 @@ def version():
     return
 
 
-# The plugins command is registered as a built-in command, before any external
-# command, so that an installed package can never replace it.
-cli.add_command(plugins)
-
-
 # ==============================================================================
 # Entry point of the mvt console script
 # ==============================================================================

src/mvt/common/cli_plugins.py

@@ -15,10 +15,6 @@ from typing import Iterable
 
 import click
 
-# This module is imported by every CLI at start-up, and by shell completion on
-# every keystroke, so it must stay cheap: nothing here may import the module
-# machinery (mvt.common.module_loader and what it pulls in).
-
 IOS_CLI_PLUGIN_GROUP = "mvt.ios.cli_plugins"
 ANDROID_CLI_PLUGIN_GROUP = "mvt.android.cli_plugins"
 # Commands in this group are registered on the platform-neutral mvt command only.
@@ -26,9 +22,6 @@ NEUTRAL_CLI_PLUGIN_GROUP = "mvt.cli_plugins"
 MVT_CUSTOM_COMMANDS_ENV = "MVT_CUSTOM_COMMANDS"
 MVT_IOS_CUSTOM_COMMANDS_ENV = "MVT_IOS_CUSTOM_COMMANDS"
 MVT_ANDROID_CUSTOM_COMMANDS_ENV = "MVT_ANDROID_CUSTOM_COMMANDS"
-# Prefix of the import name given to a command file loaded from a path. Shared
-# with module_loader, which recognises such files when naming their loggers.
-CUSTOM_COMMAND_MODULE_PREFIX = "_mvt_custom_command_"
 
 log = logging.getLogger(__name__)
 
@@ -64,7 +57,7 @@ class BrokenPluginCommand(click.Command):
 
 def _module_name_for_path(path: Path) -> str:
     digest = hashlib.sha256(str(path).encode("utf-8")).hexdigest()[:16]
-    return f"{CUSTOM_COMMAND_MODULE_PREFIX}{path.stem}_{digest}"
+    return f"_mvt_custom_command_{path.stem}_{digest}"
 
 
 def _iter_command_files(path: Path) -> Iterable[Path]:

src/mvt/common/cmd_plugins.py

@@ -1,205 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2026 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-
-import importlib.metadata
-import logging
-from typing import Optional
-
-import click
-from rich.console import Console
-from rich.table import Table
-
-from .cli_plugins import (
-    ANDROID_CLI_PLUGIN_GROUP,
-    IOS_CLI_PLUGIN_GROUP,
-    NEUTRAL_CLI_PLUGIN_GROUP,
-)
-from .config import settings
-from .help import (
-    HELP_MSG_PLUGINS,
-    HELP_MSG_PLUGINS_CHECK_UPDATES,
-    HELP_MSG_PLUGINS_LIST,
-)
-from .module import MVTModule
-from .module_loader import MODULES_ENTRY_POINT_GROUP, distribution_direct_url
-from .updates import (
-    SHORT_COMMIT_LENGTH,
-    PluginUpdates,
-    installed_plugin_distributions,
-)
-
-log = logging.getLogger(__name__)
-
-CLI_PLUGIN_GROUPS = (
-    IOS_CLI_PLUGIN_GROUP,
-    ANDROID_CLI_PLUGIN_GROUP,
-    NEUTRAL_CLI_PLUGIN_GROUP,
-)
-CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
-
-
-def _entry_points(group: str) -> list[importlib.metadata.EntryPoint]:
-    try:
-        return list(importlib.metadata.entry_points(group=group))
-    except Exception as exc:
-        log.warning("Unable to discover the entry points in group %s: %s", group, exc)
-        return []
-
-
-def _entry_point_distribution(
-    entry_point: importlib.metadata.EntryPoint,
-) -> Optional[str]:
-    dist = getattr(entry_point, "dist", None)
-    if dist is None:
-        return None
-    try:
-        return dist.name
-    except Exception:
-        return None
-
-
-def _distribution_version(dist: importlib.metadata.Distribution) -> str:
-    try:
-        return dist.version or "unknown"
-    except Exception:
-        return "unknown"
-
-
-def _distribution_origin(dist: importlib.metadata.Distribution) -> str:
-    """Describe where a plugin package was installed from."""
-    direct_url = distribution_direct_url(dist)
-    if direct_url is None:
-        return "pypi"
-
-    vcs_info = direct_url.get("vcs_info")
-    if isinstance(vcs_info, dict):
-        commit = vcs_info.get("commit_id") or ""
-        if commit:
-            return f"git+{commit[:SHORT_COMMIT_LENGTH]}"
-        return "git"
-
-    return "local"
-
-
-def _contributed_modules(
-    entry_points: list[importlib.metadata.EntryPoint], distribution: str
-) -> str:
-    """Count the forensic modules a plugin package contributes.
-
-    Entry points are resolved the way MVT resolves them when it loads
-    modules, but a broken entry point is reported instead of raising: listing
-    the installed plugins must work even when one of them is faulty.
-    """
-    count = 0
-    broken = False
-
-    for entry_point in entry_points:
-        if _entry_point_distribution(entry_point) != distribution:
-            continue
-        try:
-            loaded = entry_point.load()
-            if callable(loaded) and not isinstance(loaded, type):
-                loaded = loaded()
-            count += sum(
-                1
-                for module in loaded
-                if isinstance(module, type) and issubclass(module, MVTModule)
-            )
-        except (Exception, SystemExit) as exc:
-            log.debug(
-                "Unable to load the modules of entry point %s (%s): %s",
-                entry_point.name,
-                entry_point.value,
-                exc,
-            )
-            broken = True
-
-    if broken:
-        return f"{count} (error)" if count else "error"
-
-    return str(count)
-
-
-def _contributed_commands(
-    entry_points: list[importlib.metadata.EntryPoint], distribution: str
-) -> str:
-    names = {
-        entry_point.name
-        for entry_point in entry_points
-        if _entry_point_distribution(entry_point) == distribution
-    }
-
-    return ", ".join(sorted(names)) if names else "-"
-
-
-@click.group("plugins", context_settings=CONTEXT_SETTINGS, help=HELP_MSG_PLUGINS)
-def plugins() -> None:
-    pass
-
-
-@plugins.command("list", context_settings=CONTEXT_SETTINGS, help=HELP_MSG_PLUGINS_LIST)
-def list_plugins() -> None:
-    distributions = installed_plugin_distributions()
-    if not distributions:
-        click.echo("No MVT plugins are installed.")
-        return
-
-    module_entry_points = _entry_points(MODULES_ENTRY_POINT_GROUP)
-    command_entry_points = []
-    for group in CLI_PLUGIN_GROUPS:
-        command_entry_points.extend(_entry_points(group))
-
-    table = Table(title="Installed MVT plugins")
-    table.add_column("Name", style="bold")
-    table.add_column("Version")
-    table.add_column("Origin")
-    table.add_column("Modules", justify="right")
-    table.add_column("Commands")
-
-    for dist in distributions:
-        name = dist.name
-        table.add_row(
-            name,
-            _distribution_version(dist),
-            _distribution_origin(dist),
-            _contributed_modules(module_entry_points, name),
-            _contributed_commands(command_entry_points, name),
-        )
-
-    Console().print(table)
-
-
-@plugins.command(
-    "check-updates",
-    context_settings=CONTEXT_SETTINGS,
-    help=HELP_MSG_PLUGINS_CHECK_UPDATES,
-    short_help="Check the installed plugins for updates",
-)
-def check_plugin_updates() -> None:
-    if not settings.NETWORK_ACCESS_ALLOWED:
-        click.echo(
-            "Network access is disabled, cannot check for plugin updates. "
-            "Enable NETWORK_ACCESS_ALLOWED in the MVT configuration to check."
-        )
-        return
-
-    if not installed_plugin_distributions():
-        click.echo("No MVT plugins are installed.")
-        return
-
-    findings = PluginUpdates().check()
-    if not findings:
-        click.echo("All plugins are up to date.")
-        return
-
-    click.echo("Plugin updates available:")
-    for finding in findings:
-        click.echo(f"  {finding['name']}  {finding['installed']} → {finding['latest']}")
-        click.echo(f"    Upgrade with: {finding['upgrade_command']}")
-
-    click.echo(
-        "\nMVT does not install plugin updates. Run the command above when you "
-        "decide to upgrade."
-    )

src/mvt/common/command.py

@@ -72,10 +72,6 @@ class Command:
         # down a password to decrypt a backup or flags which are need by some modules.
         self.module_options = module_options if module_options else {}
 
-        # This dictionary maps the modules which were replaced by a module
-        # declaring `replaces` to the module which took their place.
-        self.module_replacements: dict[type[MVTModule], type[MVTModule]] = {}
-
         # This list will contain all executed modules.
         # We can use this to reference e.g. self.executed[0].results.
         self.executed: list[MVTModule] = []
@@ -261,174 +257,7 @@ class Command:
             if module not in deduplicated:
                 deduplicated.append(module)
 
-        available = self._apply_replacements(deduplicated)
-        self._warn_about_slug_collisions(available)
-
-        return available
-
-    def _warn_about_slug_collisions(self, modules: list[type[MVTModule]]) -> None:
-        """Report modules writing their results to the same file.
-
-        Results are stored in a file named after the module slug, so two
-        modules sharing one silently overwrite each other. Replacements are
-        already resolved here, so a module deliberately taking over the slug
-        of the module it replaces is not reported: the module it replaced is
-        no longer part of the run.
-        """
-        modules_by_slug: dict[str, type[MVTModule]] = {}
-        for module in modules:
-            slug = module.get_slug()
-            first = modules_by_slug.setdefault(slug, module)
-            if first is module:
-                continue
-
-            self.log.warning(
-                "Modules %s from %s and %s from %s both use the slug %s. If "
-                "both run, whichever runs last overwrites the results of the "
-                "other in %s.json.",
-                first.__name__,
-                get_module_origin(first).label,
-                module.__name__,
-                get_module_origin(module).label,
-                slug,
-                slug,
-            )
-
-    def _declared_replacements(
-        self, modules: list[type[MVTModule]]
-    ) -> dict[type[MVTModule], type[MVTModule]]:
-        """Return the replacements declared by the given modules."""
-        replacements: dict[type[MVTModule], type[MVTModule]] = {}
-        for module in modules:
-            replaced = module.replaces
-            if replaced is None or replaced is module:
-                continue
-
-            if not module.enabled:
-                # Replacing a module must not disable it, as a disabled
-                # replacement never runs in its place.
-                self.log.debug(
-                    "Module %s is disabled and does not replace module %s.",
-                    module.__name__,
-                    replaced.__name__,
-                )
-                continue
-
-            if replaced not in modules:
-                # A module can support several commands while the module it
-                # replaces is only available in some of them.
-                self.log.debug(
-                    "Module %s replaces module %s, which is not available "
-                    "for the %s command.",
-                    module.__name__,
-                    replaced.__name__,
-                    self.name,
-                )
-                continue
-
-            if replaced in replacements:
-                self.log.warning(
-                    "Modules %s and %s both replace module %s. Both of them "
-                    "will run, %s will not, and modules depending on %s will "
-                    "use the results of %s. Replacements which share the slug "
-                    "of %s overwrite each other's results file.",
-                    replacements[replaced].__name__,
-                    module.__name__,
-                    replaced.__name__,
-                    replaced.__name__,
-                    replaced.__name__,
-                    replacements[replaced].__name__,
-                    replaced.__name__,
-                )
-                continue
-
-            replacements[replaced] = module
-
-        return replacements
-
-    def _drop_replacement_cycles(
-        self, replacements: dict[type[MVTModule], type[MVTModule]]
-    ) -> None:
-        """Undo the replacements between modules which replace each other."""
-        cyclic: set[type[MVTModule]] = set()
-        for replaced in replacements:
-            walked: list[type[MVTModule]] = []
-            module = replaced
-            while module in replacements and module not in cyclic:
-                if module in walked:
-                    cyclic.update(walked[walked.index(module) :])
-                    break
-                walked.append(module)
-                module = replacements[module]
-
-        if not cyclic:
-            return
-
-        self.log.warning(
-            "Modules %s replace each other in a cycle. None of them replaces "
-            "anything and all of them will run.",
-            ", ".join(sorted(module.__name__ for module in cyclic)),
-        )
-        for module in cyclic:
-            replacements.pop(module, None)
-
-    def _log_replacement(
-        self,
-        replaced: type[MVTModule],
-        module: type[MVTModule],
-        replacement: type[MVTModule],
-    ) -> None:
-        """Report an applied replacement, and any problem with it."""
-        if not issubclass(module, replaced):
-            self.log.warning(
-                "Module %s replaces module %s but is not a subclass of it. "
-                "Its results might not be compatible with what modules "
-                "depending on %s expect.",
-                module.__name__,
-                replaced.__name__,
-                replaced.__name__,
-            )
-
-        if replaced in module.dependencies:
-            self.log.warning(
-                "Module %s depends on module %s, which it also replaces. The "
-                "dependency cannot be satisfied: a replacement has to produce "
-                "that data itself.",
-                module.__name__,
-                replaced.__name__,
-            )
-
-        self.log.info(
-            "Module %s from %s replaces module %s from %s.",
-            replacement.__name__,
-            get_module_origin(replacement).label,
-            replaced.__name__,
-            get_module_origin(replaced).label,
-        )
-
-    def _apply_replacements(
-        self, modules: list[type[MVTModule]]
-    ) -> list[type[MVTModule]]:
-        """Drop the modules superseded by a module declaring `replaces`."""
-        declared = self._declared_replacements(modules)
-        self._drop_replacement_cycles(declared)
-
-        replacements: dict[type[MVTModule], type[MVTModule]] = {}
-        for replaced, module in declared.items():
-            # Follow chains of replacements, so that a dependency on a
-            # replaced module always resolves to a module which is part of
-            # the run.
-            replacement = module
-            while replacement in declared:
-                replacement = declared[replacement]
-
-            # Only the replacements which are applied are reported, so that
-            # the record matches the modules which actually run.
-            self._log_replacement(replaced, module, replacement)
-            replacements[replaced] = replacement
-
-        self.module_replacements = replacements
-        return [module for module in modules if module not in replacements]
+        return deduplicated
 
     def init(self) -> None:
         raise NotImplementedError
@@ -488,80 +317,6 @@ class Command:
         console.print("")
         console.print(panel)
 
-    def _module_dependencies(
-        self, module: type[MVTModule]
-    ) -> list[tuple[type[MVTModule], type[MVTModule]]]:
-        """Return the (declared, resolved) dependencies of a module.
-
-        A dependency on a module which was replaced is resolved to the module
-        which took its place. A module which replaces one of its own
-        dependencies is not made to depend on itself, while a module which
-        declares itself as a dependency is left alone and still fails the
-        circular dependency check.
-        """
-        dependencies = []
-        for dependency in module.dependencies:
-            resolved = self.module_replacements.get(dependency, dependency)
-            if resolved is module and dependency is not module:
-                continue
-            dependencies.append((dependency, resolved))
-
-        return dependencies
-
-    @staticmethod
-    def _dependency_name(
-        declared: type[MVTModule], resolved: type[MVTModule]
-    ) -> str:
-        """Return how a dependency is named in the messages about it.
-
-        A dependency is named as the module which declared it wrote it, and,
-        when that module was replaced, as the module which runs in its place.
-        """
-        if declared is resolved:
-            return declared.__name__
-
-        return f"{resolved.__name__} (replacing module {declared.__name__})"
-
-    def _selected_modules(
-        self, modules: list[type[MVTModule]]
-    ) -> Optional[list[type[MVTModule]]]:
-        """Return the modules explicitly requested, or all the enabled ones.
-
-        Returns None when a module was requested by name and no module of
-        that name can be run.
-        """
-        if not self.module_name:
-            return [module for module in modules if module.enabled]
-
-        selected = [
-            module for module in modules if module.__name__ == self.module_name
-        ]
-
-        # A module replacing another one does not have to keep its name, so
-        # the name of a replaced module selects its replacement.
-        if not selected:
-            for replaced, replacement in self.module_replacements.items():
-                if replaced.__name__ != self.module_name or replacement in selected:
-                    continue
-                self.log.info(
-                    "Module %s was replaced by module %s, which is run "
-                    "in its place.",
-                    replaced.__name__,
-                    replacement.__name__,
-                )
-                selected.append(replacement)
-
-        if not selected:
-            self.log.warning(
-                "No module named %s is available for the %s command. "
-                "No modules will be run.",
-                self.module_name,
-                self.name,
-            )
-            return None
-
-        return selected
-
     def _skipped_modules(
         self,
         required: list[type[MVTModule]],
@@ -594,18 +349,15 @@ class Command:
                 if module in skipped:
                     continue
 
-                for declared, dependency in self._module_dependencies(module):
+                for dependency in module.dependencies:
                     if dependency not in module_indexes:
-                        # A replaced dependency always resolves to a module of
-                        # this command, so an unavailable one is always the
-                        # module class the author declared.
-                        skipped[module] = (module, declared)
+                        skipped[module] = (module, dependency)
                         changed = True
                         self.log.warning(
                             "Module %s will be SKIPPED: it depends on module "
                             "%s, which is not available in this command.%s",
                             module.__name__,
-                            declared.__name__,
+                            dependency.__name__,
                             remainder,
                         )
                         break
@@ -620,7 +372,7 @@ class Command:
                                 "module %s, itself skipped for depending on "
                                 "unavailable module %s.%s",
                                 module.__name__,
-                                self._dependency_name(declared, dependency),
+                                dependency.__name__,
                                 missing.__name__,
                                 remainder,
                             )
@@ -631,7 +383,7 @@ class Command:
                                 "module %s, which depends on unavailable "
                                 "module %s.%s",
                                 module.__name__,
-                                self._dependency_name(declared, dependency),
+                                dependency.__name__,
                                 root.__name__,
                                 missing.__name__,
                                 remainder,
@@ -645,9 +397,12 @@ class Command:
         modules = self._available_modules()
         module_indexes = {module: index for index, module in enumerate(modules)}
 
-        selected = self._selected_modules(modules)
-        if selected is None:
-            return None
+        if self.module_name:
+            selected = [
+                module for module in modules if module.__name__ == self.module_name
+            ]
+        else:
+            selected = [module for module in modules if module.enabled]
 
         required: set[type[MVTModule]] = set()
         pending = list(selected)
@@ -656,7 +411,7 @@ class Command:
             if module in required:
                 continue
             required.add(module)
-            for _, dependency in self._module_dependencies(module):
+            for dependency in module.dependencies:
                 # Unavailable dependencies are reported by _skipped_modules().
                 if dependency in module_indexes:
                     pending.append(dependency)
@@ -669,14 +424,13 @@ class Command:
                 "Every selected module was skipped for an unavailable "
                 "dependency. No modules will be run."
             )
-            return None
 
         dependents: dict[type[MVTModule], list[type[MVTModule]]] = {
             module: [] for module in runnable
         }
         indegree = {module: 0 for module in runnable}
         for module in runnable:
-            for _, dependency in self._module_dependencies(module):
+            for dependency in module.dependencies:
                 if dependency not in indegree:
                     continue
                 dependents[dependency].append(module)
@@ -732,12 +486,9 @@ class Command:
                 module_options=self.module_options,
                 log=module_logger,
             )
-            # Dependencies are keyed by the module class they declare, even
-            # when it was replaced, so that a module asking for the results
-            # of a replaced module receives those of its replacement.
             m.dependency_modules = {
-                dependency: executed_by_type[resolved]
-                for dependency, resolved in self._module_dependencies(module)
+                dependency: executed_by_type[dependency]
+                for dependency in module.dependencies
             }
 
             if self.iocs.total_ioc_count:

src/mvt/common/help.py

@@ -17,10 +17,6 @@ HELP_MSG_LOAD_MODULE = (
 HELP_MSG_NONINTERACTIVE = "Don't ask interactive questions during processing"
 HELP_MSG_HASHES = "Generate hashes of all the files analyzed"
 HELP_MSG_VERBOSE = "Verbose mode"
-HELP_MSG_VERBOSE_COMMAND = (
-    "Verbose mode (kept for compatibility, pass --verbose before the command "
-    "name instead)"
-)
 HELP_MSG_CHECK_IOCS = "Compare stored JSON results to provided indicators"
 HELP_MSG_STIX2 = "Download public STIX2 indicators"
 HELP_MSG_DISABLE_UPDATE_CHECK = "Disable MVT version update check"
@@ -28,11 +24,6 @@ HELP_MSG_DISABLE_INDICATOR_UPDATE_CHECK = "Disable indicators update check"
 HELP_MSG_COMPLETION = (
     "Generate or install shell completion for mvt, mvt-ios and mvt-android"
 )
-HELP_MSG_PLUGINS = "Inspect the installed MVT plugin packages"
-HELP_MSG_PLUGINS_LIST = "List the installed plugins and what they contribute to MVT"
-HELP_MSG_PLUGINS_CHECK_UPDATES = (
-    "Check the installed plugins for updates without installing them"
-)
 
 # IOS Specific
 HELP_MSG_DECRYPT_BACKUP = "Decrypt an encrypted iTunes backup"

src/mvt/common/logo.py

@@ -8,125 +8,10 @@ import logging
 import requests
 from rich import print as rich_print
 
-from .config import settings
-from .updates import (
-    IndicatorsUpdates,
-    MVTUpdates,
-    PluginUpdates,
-    installed_plugin_distributions,
-)
+from .updates import IndicatorsUpdates, MVTUpdates
 from .version import MVT_VERSION
 
 
-def _check_version_updates(log: logging.Logger) -> None:
-    try:
-        mvt_updates = MVTUpdates()
-        latest_version = mvt_updates.check()
-    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
-        rich_print(
-            "\t[bold]Note: Could not check for MVT updates.[/bold] "
-            "You may be working offline. Please update MVT regularly."
-        )
-    except Exception as e:
-        log.error("Error encountered when trying to check latest MVT version: %s", e)
-    else:
-        if latest_version:
-            rich_print(
-                f"\t[bold]Version {latest_version} is available! "
-                "Upgrade mvt with `pip3 install -U mvt` or with `pipx upgrade mvt`[/bold]"
-            )
-
-
-def _check_indicator_updates(log: logging.Logger) -> None:
-    ioc_updates = IndicatorsUpdates()
-
-    # Before proceeding, we check if we have downloaded an indicators index.
-    # If not, there's no point in proceeding with the updates check.
-    if ioc_updates.get_latest_update() == 0:
-        rich_print(
-            "\t[bold]You have not yet downloaded any indicators, check "
-            "the `download-iocs` command![/bold]"
-        )
-        return
-
-    # We only perform this check at a fixed frequency, in order to not
-    # overburden the user with too many lookups if the command is being run
-    # multiple times.
-    should_check, hours = ioc_updates.should_check()
-    if not should_check:
-        rich_print(
-            f"\tIndicators updates checked recently, next automatic check "
-            f"in {int(hours)} hours"
-        )
-        return
-
-    try:
-        ioc_to_update = ioc_updates.check()
-    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
-        rich_print(
-            "\t[bold]Note: Could not check for indicator updates.[/bold] "
-            "You may be working offline. Please update MVT indicators regularly."
-        )
-    except Exception as e:
-        log.error("Error encountered when trying to check latest MVT indicators: %s", e)
-    else:
-        if ioc_to_update:
-            rich_print(
-                "\t[bold]There are updates to your indicators files! "
-                "Run the `download-iocs` command to update![/bold]"
-            )
-        else:
-            rich_print("\tYour indicators files seem to be up to date.")
-
-
-def _print_plugin_updates(findings: list) -> None:
-    if not findings:
-        return
-
-    rich_print("\t[bold]Plugin updates available:[/bold]")
-    for finding in findings:
-        rich_print(
-            f"\t  {finding['name']}  {finding['installed']} → "
-            f"{finding['latest']}   ({finding['upgrade_command']})"
-        )
-
-
-def _check_plugin_updates(log: logging.Logger) -> None:
-    if not settings.NETWORK_ACCESS_ALLOWED:
-        return
-
-    # This runs on every command, so nothing here, including reading back what
-    # the latest check stored, may ever interrupt MVT.
-    try:
-        distributions = installed_plugin_distributions()
-
-        # There is nothing to check when MVT was not extended with any plugin.
-        if not distributions:
-            return
-
-        plugin_updates = PluginUpdates()
-
-        # We only perform this check at a fixed frequency, in order to not
-        # overburden the user (and the plugin repositories) with too many
-        # lookups. In between checks we print the findings of the latest one,
-        # leaving out those which no longer apply to what is installed.
-        should_check, _ = plugin_updates.should_check()
-        if not should_check:
-            _print_plugin_updates(plugin_updates.current_findings(distributions))
-            return
-
-        findings = plugin_updates.check()
-    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
-        rich_print(
-            "\t[bold]Note: Could not check for plugin updates.[/bold] "
-            "You may be working offline. Please update your MVT plugins regularly."
-        )
-    except Exception as e:
-        log.error("Error encountered when trying to check MVT plugin updates: %s", e)
-    else:
-        _print_plugin_updates(findings)
-
-
 def check_updates(
     disable_version_check: bool = False, disable_indicator_check: bool = False
 ) -> None:
@@ -134,16 +19,68 @@ def check_updates(
 
     # First we check for MVT version updates.
     if not disable_version_check:
-        _check_version_updates(log)
+        try:
+            mvt_updates = MVTUpdates()
+            latest_version = mvt_updates.check()
+        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+            rich_print(
+                "\t[bold]Note: Could not check for MVT updates.[/bold] "
+                "You may be working offline. Please update MVT regularly."
+            )
+        except Exception as e:
+            log.error(
+                "Error encountered when trying to check latest MVT version: %s", e
+            )
+        else:
+            if latest_version:
+                rich_print(
+                    f"\t[bold]Version {latest_version} is available! "
+                    "Upgrade mvt with `pip3 install -U mvt` or with `pipx upgrade mvt`[/bold]"
+                )
 
     # Then we check for indicators files updates.
     if not disable_indicator_check:
-        _check_indicator_updates(log)
+        ioc_updates = IndicatorsUpdates()
 
-    # Finally we check for updates to the installed plugin packages. MVT never
-    # installs an update itself, it only reports the command which does.
-    if not disable_version_check:
-        _check_plugin_updates(log)
+        # Before proceeding, we check if we have downloaded an indicators index.
+        # If not, there's no point in proceeding with the updates check.
+        if ioc_updates.get_latest_update() == 0:
+            rich_print(
+                "\t[bold]You have not yet downloaded any indicators, check "
+                "the `download-iocs` command![/bold]"
+            )
+            return
+
+        # We only perform this check at a fixed frequency, in order to not
+        # overburden the user with too many lookups if the command is being run
+        # multiple times.
+        should_check, hours = ioc_updates.should_check()
+        if not should_check:
+            rich_print(
+                f"\tIndicators updates checked recently, next automatic check "
+                f"in {int(hours)} hours"
+            )
+            return
+
+        try:
+            ioc_to_update = ioc_updates.check()
+        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+            rich_print(
+                "\t[bold]Note: Could not check for indicator updates.[/bold] "
+                "You may be working offline. Please update MVT indicators regularly."
+            )
+        except Exception as e:
+            log.error(
+                "Error encountered when trying to check latest MVT indicators: %s", e
+            )
+        else:
+            if ioc_to_update:
+                rich_print(
+                    "\t[bold]There are updates to your indicators files! "
+                    "Run the `download-iocs` command to update![/bold]"
+                )
+            else:
+                rich_print("\tYour indicators files seem to be up to date.")
 
 
 def logo(

src/mvt/common/module.py

@@ -46,11 +46,6 @@ class MVTModule:
     slug: Optional[str] = None
     dependencies: Sequence[type["MVTModule"]] = ()
     supported_commands: Sequence[tuple[str, str]] = ()
-    # A custom module can name a module class it supersedes, usually a
-    # built-in one. When both are available to a command, the named module is
-    # dropped from the run and this module takes its place, including in the
-    # dependencies of any other module.
-    replaces: Optional[type["MVTModule"]] = None
 
     def __init__(
         self,

src/mvt/common/module_loader.py

@@ -10,7 +10,6 @@ import inspect
 import json
 import logging
 import os
-import re
 import sys
 from dataclasses import dataclass
 from functools import lru_cache
@@ -18,7 +17,6 @@ from pathlib import Path
 from types import ModuleType
 from typing import Iterable, Optional
 
-from .cli_plugins import CUSTOM_COMMAND_MODULE_PREFIX
 from .module import MVTModule
 from .version import MVT_VERSION
 
@@ -28,7 +26,6 @@ EXTERNAL_LOGGER_NAMESPACE = "mvt.ext"
 PLUGIN_PACKAGE_PREFIX = "mvt_plugin_"
 _ORIGIN_ATTRIBUTE = "_mvt_module_origin"
 _PATH_MODULE_PREFIX = "_mvt_custom_module_"
-_LOADED_FILE_DIGEST = re.compile(r"_[0-9a-f]{16}$")
 log = logging.getLogger(__name__)
 
 
@@ -69,25 +66,6 @@ def _module_name_for_path(path: Path) -> str:
     return f"{_PATH_MODULE_PREFIX}{path.stem}_{digest}"
 
 
-def _is_builtin_logger_name(name: str) -> bool:
-    return name == "mvt" or name.startswith("mvt.")
-
-
-def _loaded_file_stem(name: str, prefix: str) -> str:
-    """Recover a loaded file's name from the import name MVT gave it."""
-    return _LOADED_FILE_DIGEST.sub("", name[len(prefix) :])
-
-
-def _external_logger_name(name: str) -> str:
-    """Return the "mvt.ext" logger name external code logs under."""
-    top_level, separator, rest = name.partition(".")
-    if top_level.startswith(PLUGIN_PACKAGE_PREFIX) and len(top_level) > len(
-        PLUGIN_PACKAGE_PREFIX
-    ):
-        name = top_level[len(PLUGIN_PACKAGE_PREFIX) :] + separator + rest
-    return f"{EXTERNAL_LOGGER_NAMESPACE}.{name}"
-
-
 def get_module_logger(module_class: type[MVTModule]) -> logging.Logger:
     """Return the logger a module's records should be emitted through.
 
@@ -102,35 +80,19 @@ def get_module_logger(module_class: type[MVTModule]) -> logging.Logger:
     "mvt_plugin_<name>" naming convention log under "mvt.ext.<name>".
     """
     name = module_class.__module__
-    if _is_builtin_logger_name(name):
+    if name == "mvt" or name.startswith("mvt."):
         return logging.getLogger(name)
 
     if name.startswith(_PATH_MODULE_PREFIX):
-        file_name = Path(get_module_origin(module_class).name).stem
-        return logging.getLogger(f"{EXTERNAL_LOGGER_NAMESPACE}.{file_name}")
+        name = Path(get_module_origin(module_class).name).stem
+    else:
+        top_level, separator, rest = name.partition(".")
+        if top_level.startswith(PLUGIN_PACKAGE_PREFIX) and len(top_level) > len(
+            PLUGIN_PACKAGE_PREFIX
+        ):
+            name = top_level[len(PLUGIN_PACKAGE_PREFIX) :] + separator + rest
 
-    return logging.getLogger(_external_logger_name(name))
-
-
-def get_plugin_logger(name: str) -> logging.Logger:
-    """Return a general logger for use in custom MVT plugins.
-
-    Call it with ``__name__``. The logger sits under "mvt.ext". That is
-    where get_module_logger() puts module classes. A file loaded with
-    --load-module or --load-command is named after the file.
-    """
-    if _is_builtin_logger_name(name):
-        return logging.getLogger(name)
-
-    # A file loaded with --load-module or --load-command is imported under a
-    # mangled name. Log it under the file it came from. get_module_logger()
-    # does the same for the module classes such a file defines.
-    for prefix in (_PATH_MODULE_PREFIX, CUSTOM_COMMAND_MODULE_PREFIX):
-        if name.startswith(prefix):
-            stem = _loaded_file_stem(name, prefix)
-            return logging.getLogger(f"{EXTERNAL_LOGGER_NAMESPACE}.{stem}")
-
-    return logging.getLogger(_external_logger_name(name))
+    return logging.getLogger(f"{EXTERNAL_LOGGER_NAMESPACE}.{name}")
 
 
 def _iter_module_files(path: Path) -> Iterable[Path]:
@@ -217,36 +179,21 @@ def _module_key(module_class: type[MVTModule]) -> tuple[str, str]:
     return (source, module_class.__qualname__)
 
 
-def distribution_direct_url(dist: importlib.metadata.Distribution) -> Optional[dict]:
-    """Return the PEP 610 direct URL metadata of a distribution, if recorded.
-
-    Packages installed from an index have no direct URL metadata, while
-    packages installed directly from a repository or from a local folder
-    record where they were installed from in ``direct_url.json``.
-    """
-    try:
-        direct_url_text = dist.read_text("direct_url.json")
-        if not direct_url_text:
-            return None
-        direct_url = json.loads(direct_url_text)
-        return direct_url if isinstance(direct_url, dict) else None
-    except Exception:
-        return None
-
-
 def _distribution_commit(dist: importlib.metadata.Distribution) -> Optional[str]:
     """Return the VCS commit a distribution was installed from, if recorded.
 
     Packages installed directly from a repository (``pip install git+...``)
     record the commit in ``direct_url.json`` (PEP 610).
     """
-    vcs_info = (distribution_direct_url(dist) or {}).get("vcs_info")
-    if not isinstance(vcs_info, dict):
+    try:
+        direct_url_text = dist.read_text("direct_url.json")
+        if not direct_url_text:
+            return None
+        commit = json.loads(direct_url_text).get("vcs_info", {}).get("commit_id")
+        return commit if isinstance(commit, str) else None
+    except Exception:
         return None
 
-    commit = vcs_info.get("commit_id")
-    return commit if isinstance(commit, str) else None
-
 
 def _entry_point_origin(entry_point: importlib.metadata.EntryPoint) -> ModuleOrigin:
     name = entry_point.name
@@ -401,14 +348,4 @@ def module_supports_command(
         )
         return False
 
-    pairs = {tuple(entry) for entry in supported_commands}
-    if (platform, command) in pairs:
-        return True
-
-    # A module which implements check_indicators() is re-checked by check-iocs
-    # for its platform. It does not need to declare the check-iocs pair.
-    return (
-        command == "check-iocs"
-        and platform in {entry[0] for entry in pairs if entry}
-        and module_class.check_indicators is not MVTModule.check_indicators
-    )
+    return (platform, command) in {tuple(entry) for entry in supported_commands}

src/mvt/common/updates.py

@@ -3,13 +3,8 @@
 # Use of this software is governed by the MVT License 1.1 that can be found at
 #   https://license.mvt.re/1.1/
 
-import importlib.metadata
-import json
 import logging
 import os
-import re
-import shlex
-import subprocess
 from datetime import datetime
 from typing import Optional, Tuple
 
@@ -17,35 +12,14 @@ import requests
 import yaml
 from packaging import version
 
-from .cli_plugins import (
-    ANDROID_CLI_PLUGIN_GROUP,
-    IOS_CLI_PLUGIN_GROUP,
-    NEUTRAL_CLI_PLUGIN_GROUP,
-)
 from .config import settings
 from .indicators import MVT_DATA_FOLDER, MVT_INDICATORS_FOLDER
-from .module_loader import MODULES_ENTRY_POINT_GROUP, distribution_direct_url
 from .version import MVT_VERSION
 
 log = logging.getLogger(__name__)
 
 # In hours.
 INDICATORS_CHECK_FREQUENCY = 12
-PLUGINS_CHECK_FREQUENCY = 12
-
-# The entry-point groups a package can use to extend MVT.
-PLUGIN_ENTRY_POINT_GROUPS = (
-    MODULES_ENTRY_POINT_GROUP,
-    IOS_CLI_PLUGIN_GROUP,
-    ANDROID_CLI_PLUGIN_GROUP,
-    NEUTRAL_CLI_PLUGIN_GROUP,
-)
-SHORT_COMMIT_LENGTH = 8
-# The keys every cached finding has to carry to be printed.
-FINDING_KEYS = ("name", "installed", "latest", "upgrade_command")
-# Options which stop ssh from waiting for an answer nobody is there to give.
-_SSH_BATCH_OPTIONS = ("-o", "BatchMode=yes", "-o", "ConnectTimeout=10")
-_COMMIT_PATTERN = re.compile(r"\A[0-9a-f]{7,40}\Z")
 
 
 class MVTUpdates:
@@ -64,395 +38,6 @@ class MVTUpdates:
         return ""
 
 
-def installed_plugin_distributions() -> list[importlib.metadata.Distribution]:
-    """Return the installed distributions which extend MVT.
-
-    A plugin package is any distribution registering at least one entry point
-    in the module or CLI command groups. Distributions are returned once each,
-    sorted by name. MVT itself is not a plugin and is never returned.
-    """
-    distributions: dict[str, importlib.metadata.Distribution] = {}
-
-    for group in PLUGIN_ENTRY_POINT_GROUPS:
-        try:
-            entry_points = importlib.metadata.entry_points(group=group)
-        except Exception as exc:
-            log.warning(
-                "Unable to discover installed plugin packages in entry-point "
-                "group %s: %s",
-                group,
-                exc,
-            )
-            continue
-
-        for entry_point in entry_points:
-            # Manually constructed entry points have no associated distribution.
-            dist = getattr(entry_point, "dist", None)
-            if dist is None:
-                continue
-            try:
-                name = dist.name
-            except Exception:
-                continue
-            if not name or name == "mvt":
-                continue
-            distributions.setdefault(name, dist)
-
-    return [distributions[name] for name in sorted(distributions)]
-
-
-def _is_usable_finding(finding: object) -> bool:
-    """Check that a cached finding carries everything needed to print it."""
-    if not isinstance(finding, dict):
-        return False
-
-    return all(
-        isinstance(finding.get(key), str) and finding.get(key) for key in FINDING_KEYS
-    )
-
-
-def _installed_revision(
-    dist: importlib.metadata.Distribution, origin: object
-) -> Optional[str]:
-    """Return what a plugin's installed revision is right now.
-
-    This is the value a finding recorded as installed when it was made, so a
-    finding can be compared against the current state of the installation
-    without looking anything up remotely.
-    """
-    try:
-        if origin != "git":
-            return dist.version
-
-        vcs_info = (distribution_direct_url(dist) or {}).get("vcs_info")
-        if not isinstance(vcs_info, dict):
-            return None
-
-        commit = vcs_info.get("commit_id") or ""
-        return commit[:SHORT_COMMIT_LENGTH] or None
-    except Exception as e:
-        log.debug("Failed to read the installed revision of a plugin: %s", e)
-        return None
-
-
-def _batch_mode_ssh_command(ssh_command: str) -> str:
-    """Return an ssh command line which cannot stop to ask a question.
-
-    ssh keeps the first value it is given for a keyword, so the batch mode
-    options are inserted right after the ssh program, ahead of whatever the
-    analyst configured. Their remaining options, such as which key to use,
-    still apply.
-    """
-    try:
-        arguments = shlex.split(ssh_command.strip())
-    except ValueError:
-        arguments = []
-
-    if not arguments:
-        arguments = ["ssh"]
-
-    return shlex.join([arguments[0], *_SSH_BATCH_OPTIONS, *arguments[1:]])
-
-
-def _revision_pins_commit(revision: str, commit: str) -> bool:
-    """Check whether a requested revision pins the installed commit."""
-    candidate = revision.lower()
-    if not _COMMIT_PATTERN.match(candidate):
-        return False
-
-    return commit.lower().startswith(candidate)
-
-
-class PluginUpdates:
-    """Check for updates to the installed MVT plugin packages.
-
-    MVT never installs or upgrades a plugin package itself. It only reports
-    the command which upgrades a plugin, leaving the analyst to decide when to
-    run it.
-    """
-
-    @property
-    def latest_check_path(self) -> str:
-        return os.path.join(MVT_DATA_FOLDER, "latest_plugins_check")
-
-    @property
-    def findings_path(self) -> str:
-        return os.path.join(MVT_DATA_FOLDER, "plugin_updates.json")
-
-    def _create_data_folder(self) -> None:
-        if not os.path.exists(MVT_DATA_FOLDER):
-            os.makedirs(MVT_DATA_FOLDER)
-
-    def get_latest_check(self) -> int:
-        if not os.path.exists(self.latest_check_path):
-            return 0
-
-        # A corrupt or truncated timestamp only means the next check happens
-        # sooner. It must never stop MVT from running.
-        try:
-            with open(self.latest_check_path, "r", encoding="utf-8") as handle:
-                data = handle.read().strip()
-            if data:
-                return int(data)
-        except (OSError, ValueError) as e:
-            log.debug("Failed to read the time of the latest plugin check: %s", e)
-
-        return 0
-
-    def set_latest_check(self) -> None:
-        self._create_data_folder()
-        timestamp = int(datetime.now().timestamp())
-        with open(self.latest_check_path, "w", encoding="utf-8") as handle:
-            handle.write(str(timestamp))
-
-    def get_findings(self) -> list[dict]:
-        """
-        Return the findings of the latest check, without checking again.
-        Returns an empty list if no check was ever performed.
-        """
-        if not os.path.exists(self.findings_path):
-            return []
-
-        try:
-            with open(self.findings_path, "r", encoding="utf-8") as handle:
-                findings = json.load(handle)
-        except Exception as e:
-            log.debug("Failed to read the cached plugin updates: %s", e)
-            return []
-
-        if not isinstance(findings, list):
-            return []
-
-        # Anything which does not look like a finding is dropped rather than
-        # trusted: the cache is only a convenience.
-        return [finding for finding in findings if _is_usable_finding(finding)]
-
-    def current_findings(
-        self, distributions: Optional[list[importlib.metadata.Distribution]] = None
-    ) -> list[dict]:
-        """
-        Return the cached findings which still apply to what is installed.
-        Findings about a plugin which was upgraded or removed since the latest
-        check are dropped, so an update is never reported twice.
-        """
-        if distributions is None:
-            distributions = installed_plugin_distributions()
-
-        installed = {}
-        for dist in distributions:
-            try:
-                installed[dist.name] = dist
-            except Exception:
-                continue
-
-        current = []
-        for finding in self.get_findings():
-            plugin = installed.get(finding["name"])
-            if plugin is None:
-                continue
-            if (
-                _installed_revision(plugin, finding.get("origin"))
-                != finding["installed"]
-            ):
-                continue
-            current.append(finding)
-
-        return current
-
-    def set_findings(self, findings: list[dict]) -> None:
-        self._create_data_folder()
-        with open(self.findings_path, "w", encoding="utf-8") as handle:
-            json.dump(findings, handle)
-
-    def should_check(self) -> Tuple[bool, int]:
-        """
-        Compare time of the latest plugins check with current time.
-        Returns bool and number of hours since the last check.
-        """
-        now = datetime.now()
-        latest_check_ts = self.get_latest_check()
-        latest_check_dt = datetime.fromtimestamp(latest_check_ts)
-
-        diff = now - latest_check_dt
-        diff_hours = divmod(diff.total_seconds(), 3600)[0]
-
-        if diff_hours >= PLUGINS_CHECK_FREQUENCY:
-            return True, 0
-
-        return False, int(PLUGINS_CHECK_FREQUENCY - diff_hours)
-
-    def _check_index_plugin(self, name: str, installed: str) -> Optional[dict]:
-        """Check a plugin installed from a package index for a newer release."""
-        url = f"https://pypi.org/pypi/{name}/json"
-        try:
-            res = requests.get(url, timeout=settings.NETWORK_TIMEOUT)
-        except requests.exceptions.RequestException as e:
-            log.debug("Failed to check for updates to plugin %s: %s", name, e)
-            return None
-
-        # Plugins which were never published to a public index are expected,
-        # and there is nothing to compare their version against.
-        if res.status_code == 404:
-            return None
-
-        if res.status_code != 200:
-            log.debug(
-                "Failed to check for updates to plugin %s (error %d)",
-                name,
-                res.status_code,
-            )
-            return None
-
-        try:
-            latest = res.json().get("info", {}).get("version", "")
-            if not latest or version.parse(latest) <= version.parse(installed):
-                return None
-        except Exception as e:
-            log.debug("Failed to compare the versions of plugin %s: %s", name, e)
-            return None
-
-        return {
-            "name": name,
-            "installed": installed,
-            "latest": latest,
-            "origin": "pypi",
-            # The name comes from package metadata, so the command MVT
-            # suggests is quoted rather than assumed to be shell-safe.
-            "upgrade_command": f"pip install -U {shlex.quote(name)}",
-        }
-
-    def _git_ls_remote(self, url: str, revision: str) -> list[Tuple[str, str]]:
-        """Return the remote references matching a revision, if git allows it."""
-        # Neither value is trusted: they are read from the metadata of an
-        # installed package and must not turn into git options.
-        if url.startswith("-") or revision.startswith("-"):
-            log.debug("Skipping the update check for the invalid repository %s", url)
-            return []
-
-        environment = dict(os.environ)
-        # Never prompt the analyst for repository credentials. git handles its
-        # own prompts, while ssh reads the terminal directly and only batch
-        # mode makes it fail instead of asking.
-        environment["GIT_TERMINAL_PROMPT"] = "0"
-        environment["GIT_SSH_COMMAND"] = _batch_mode_ssh_command(
-            environment.get("GIT_SSH_COMMAND", "")
-        )
-
-        try:
-            process = subprocess.run(
-                ["git", "ls-remote", url, revision],
-                capture_output=True,
-                stdin=subprocess.DEVNULL,
-                text=True,
-                env=environment,
-                timeout=settings.NETWORK_TIMEOUT,
-                check=False,
-            )
-        except FileNotFoundError:
-            log.debug("Could not find git, skipping the update check for %s", url)
-            return []
-        except (subprocess.SubprocessError, OSError) as e:
-            log.debug("Failed to query the repository %s: %s", url, e)
-            return []
-
-        if process.returncode != 0:
-            log.debug(
-                "Failed to query the repository %s (error %d): %s",
-                url,
-                process.returncode,
-                (process.stderr or "").strip(),
-            )
-            return []
-
-        references = []
-        for line in (process.stdout or "").splitlines():
-            commit, _, reference = line.partition("\t")
-            if commit.strip() and reference.strip():
-                references.append((commit.strip(), reference.strip()))
-
-        return references
-
-    def _check_repository_plugin(
-        self, name: str, direct_url: dict, vcs_info: dict
-    ) -> Optional[dict]:
-        """Check a plugin installed from a repository for a newer commit."""
-        url = direct_url.get("url") or ""
-        installed = vcs_info.get("commit_id") or ""
-        revision = vcs_info.get("requested_revision") or ""
-        if not url or not installed:
-            return None
-
-        # A plugin installed from a commit is pinned and never goes out of
-        # date, no matter what the branch it came from does next.
-        if revision and _revision_pins_commit(revision, installed):
-            return None
-
-        latest = ""
-        wanted_reference = f"refs/heads/{revision}" if revision else "HEAD"
-        for commit, reference in self._git_ls_remote(url, revision or "HEAD"):
-            # Tags are pinned installs too.
-            if reference.startswith("refs/tags/"):
-                return None
-            if reference == wanted_reference:
-                latest = commit
-
-        if not latest or latest == installed:
-            return None
-
-        requirement = f"{name} @ git+{url}"
-        if revision:
-            requirement += f"@{revision}"
-
-        return {
-            "name": name,
-            "installed": installed[:SHORT_COMMIT_LENGTH],
-            "latest": latest[:SHORT_COMMIT_LENGTH],
-            "origin": "git",
-            # A repository URL and a branch name can both hold characters a
-            # shell would act on, so the requirement is quoted for the shell
-            # the analyst is going to paste the command into.
-            "upgrade_command": f"pip install -U {shlex.quote(requirement)}",
-        }
-
-    def _check_distribution(
-        self, dist: importlib.metadata.Distribution
-    ) -> Optional[dict]:
-        try:
-            name = dist.name
-            installed = dist.version
-        except Exception as e:
-            log.debug("Failed to read the metadata of an installed plugin: %s", e)
-            return None
-
-        direct_url = distribution_direct_url(dist)
-        if direct_url is None:
-            return self._check_index_plugin(name, installed)
-
-        vcs_info = direct_url.get("vcs_info")
-        if isinstance(vcs_info, dict):
-            return self._check_repository_plugin(name, direct_url, vcs_info)
-
-        # Plugins installed from a local folder, including editable installs,
-        # are maintained by the analyst and have nothing to check against.
-        return None
-
-    def check(self) -> list[dict]:
-        """
-        Check every installed plugin package for an available update.
-        Returns one entry per plugin which can be upgraded.
-        """
-        findings = []
-        for dist in installed_plugin_distributions():
-            finding = self._check_distribution(dist)
-            if finding:
-                findings.append(finding)
-
-        self.set_findings(findings)
-        self.set_latest_check()
-
-        return findings
-
-
 class IndicatorsUpdates:
     def __init__(self) -> None:
         self.github_raw_url = "https://raw.githubusercontent.com/{}/{}/{}/{}"
@@ -595,7 +180,9 @@ class IndicatorsUpdates:
     def _get_remote_file_latest_commit(
         self, owner: str, repo: str, branch: str, path: str
     ) -> int:
-        file_commit_url = f"https://api.github.com/repos/{owner}/{repo}/commits?path={path}&sha={branch}"
+        file_commit_url = (
+            f"https://api.github.com/repos/{owner}/{repo}/commits?path={path}&sha={branch}"
+        )
         try:
             res = requests.get(file_commit_url, timeout=5)
         except requests.exceptions.RequestException as e:

src/mvt/common/utils.py

@@ -14,6 +14,7 @@ from dataclasses import asdict, is_dataclass
 from typing import Any, Iterator, Union
 
 from .log import MVTLogHandler
+from mvt.common.config import settings
 
 
 class CustomJSONEncoder(json.JSONEncoder):
@@ -255,26 +256,16 @@ def init_logging(verbose: bool = False):
 
 
 def set_verbose_logging(verbose: bool = False):
-    """Raise or lower the verbosity of MVT's console output.
-
-    Only MVT's own console handler is adjusted, wherever it sits in the list.
-    The file handler a command attaches to its output folder keeps recording
-    everything, so the command.log of a run does not depend on how the run was
-    invoked, and a handler attached to the "mvt" logger by anything else is
-    left alone.
-    """
     log = logging.getLogger("mvt")
-    for handler in log.handlers:
-        if isinstance(handler, MVTLogHandler):
-            handler.setLevel(logging.DEBUG if verbose else logging.INFO)
+    handler = log.handlers[0]
+    if verbose:
+        handler.setLevel(logging.DEBUG)
+    else:
+        handler.setLevel(logging.INFO)
 
 
 def exec_or_profile(module, globals, locals):
     """Hook for profiling MVT modules"""
-    # Imported here so that the CLI modules, which import this one at start-up,
-    # do not load the settings (and pydantic) before a command runs.
-    from .config import settings
-
     if settings.PROFILE:
         cProfile.runctx(module, globals, locals)
     else:

src/mvt/ios/cli.py

@@ -14,7 +14,10 @@ from mvt.common.cli_plugins import (
     load_cli_commands_option,
     register_cli_plugins,
 )
+from mvt.common.cmd_check_iocs import CmdCheckIOCS
+from mvt.common.logo import logo
 from mvt.common.options import MutuallyExclusiveOption
+from mvt.common.updates import IndicatorsUpdates
 from mvt.common.utils import (
     generate_hashes_from_path,
     init_logging,
@@ -35,7 +38,6 @@ from mvt.common.help import (
     HELP_MSG_LOAD_MODULE,
     HELP_MSG_MODULE,
     HELP_MSG_VERBOSE,
-    HELP_MSG_VERBOSE_COMMAND,
     HELP_MSG_CHECK_FS,
     HELP_MSG_CHECK_IOCS,
     HELP_MSG_STIX2,
@@ -44,12 +46,15 @@ from mvt.common.help import (
     HELP_MSG_DISABLE_UPDATE_CHECK,
     HELP_MSG_DISABLE_INDICATOR_UPDATE_CHECK,
 )
+from mvt.common.module_loader import CustomModuleLoadError, load_custom_modules
 from mvt.common.password import prompt_password
-
-# The commands import what they run only when they are invoked. This module is
-# imported at every start of mvt-ios, including by shell completion on every
-# keystroke, so importing it must do no more than build the command tree: the
-# forensic modules, the backup decryption and the update checks stay out of it.
+from .cmd_check_backup import CmdIOSCheckBackup
+from .cmd_check_fs import CmdIOSCheckFS
+from .cmd_check_sysdiagnose import CmdIOSCheckSysdiagnose
+from .decrypt import DecryptBackup
+from .modules.backup import BACKUP_MODULES
+from .modules.fs import FS_MODULES
+from .modules.mixed import MIXED_MODULES
 
 init_logging()
 log = logging.getLogger("mvt")
@@ -69,14 +74,7 @@ def _get_disable_flags(ctx):
     )
 
 
-def _get_verbose(ctx):
-    """Return whether --verbose was passed to the CLI itself."""
-    return bool(ctx.obj and ctx.obj.get("verbose", False))
-
-
 def _load_custom_modules(load_module):
-    from mvt.common.module_loader import CustomModuleLoadError, load_custom_modules
-
     try:
         return load_custom_modules(load_module)
     except CustomModuleLoadError as exc:
@@ -96,17 +94,11 @@ def _load_custom_modules(load_module):
     is_flag=True,
     help=HELP_MSG_DISABLE_INDICATOR_UPDATE_CHECK,
 )
-@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE)
 @click.pass_context
-def cli(ctx, disable_update_check, disable_indicator_update_check, verbose):
+def cli(ctx, disable_update_check, disable_indicator_update_check):
     ctx.ensure_object(dict)
     ctx.obj["disable_version_check"] = disable_update_check
     ctx.obj["disable_indicator_check"] = disable_indicator_update_check
-    ctx.obj["verbose"] = verbose
-    set_verbose_logging(verbose)
-
-    from mvt.common.logo import logo
-
     logo(
         disable_version_check=disable_update_check,
         disable_indicator_check=disable_indicator_update_check,
@@ -147,8 +139,6 @@ def version():
 @click.argument("BACKUP_PATH", type=click.Path(exists=True))
 @click.pass_context
 def decrypt_backup(ctx, destination, password, key_file, hashes, backup_path):
-    from .decrypt import DecryptBackup
-
     backup = DecryptBackup(backup_path, destination)
 
     if key_file:
@@ -212,8 +202,6 @@ def decrypt_backup(ctx, destination, password, key_file, hashes, backup_path):
 )
 @click.argument("BACKUP_PATH", type=click.Path(exists=True))
 def extract_key(password, key_file, backup_path):
-    from .decrypt import DecryptBackup
-
     backup = DecryptBackup(backup_path)
 
     if password:
@@ -266,7 +254,7 @@ def extract_key(password, key_file, backup_path):
     help=HELP_MSG_LOAD_MODULE,
 )
 @click.option("--hashes", "-H", is_flag=True, help=HELP_MSG_HASHES)
-@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE_COMMAND)
+@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE)
 @click.argument("BACKUP_PATH", type=click.Path(exists=True))
 @click.pass_context
 def check_backup(
@@ -281,9 +269,7 @@ def check_backup(
     verbose,
     backup_path,
 ):
-    from .cmd_check_backup import CmdIOSCheckBackup
-
-    set_verbose_logging(verbose or _get_verbose(ctx))
+    set_verbose_logging(verbose)
     module_options = {"fast_mode": fast}
     custom_modules = _load_custom_modules(load_module)
 
@@ -337,7 +323,7 @@ def check_backup(
     help=HELP_MSG_LOAD_MODULE,
 )
 @click.option("--hashes", "-H", is_flag=True, help=HELP_MSG_HASHES)
-@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE_COMMAND)
+@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE)
 @click.argument("DUMP_PATH", type=click.Path(exists=True))
 @click.pass_context
 def check_fs(
@@ -352,9 +338,7 @@ def check_fs(
     verbose,
     dump_path,
 ):
-    from .cmd_check_fs import CmdIOSCheckFS
-
-    set_verbose_logging(verbose or _get_verbose(ctx))
+    set_verbose_logging(verbose)
     module_options = {"fast_mode": fast}
     custom_modules = _load_custom_modules(load_module)
 
@@ -408,7 +392,7 @@ def check_fs(
     help=HELP_MSG_LOAD_MODULE,
 )
 @click.option("--hashes", "-H", is_flag=True, help=HELP_MSG_HASHES)
-@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE_COMMAND)
+@click.option("--verbose", "-v", is_flag=True, help=HELP_MSG_VERBOSE)
 @click.argument("SYSDIAGNOSE_PATH", type=click.Path(exists=True))
 @click.pass_context
 def check_sysdiagnose(
@@ -422,9 +406,7 @@ def check_sysdiagnose(
     verbose,
     sysdiagnose_path,
 ):
-    from .cmd_check_sysdiagnose import CmdIOSCheckSysdiagnose
-
-    set_verbose_logging(verbose or _get_verbose(ctx))
+    set_verbose_logging(verbose)
     custom_modules = _load_custom_modules(load_module)
     cmd = CmdIOSCheckSysdiagnose(
         target_path=sysdiagnose_path,
@@ -478,10 +460,6 @@ def check_sysdiagnose(
 @click.argument("FOLDER", type=click.Path(exists=True))
 @click.pass_context
 def check_iocs(ctx, iocs, list_modules, module, load_module, folder):
-    from mvt.common.cmd_check_iocs import CmdCheckIOCS
-
-    from .command_modules import IOS_CHECK_IOCS_MODULES
-
     custom_modules = _load_custom_modules(load_module)
     cmd = CmdCheckIOCS(
         target_path=folder,
@@ -492,7 +470,7 @@ def check_iocs(ctx, iocs, list_modules, module, load_module, folder):
         custom_modules=custom_modules,
         platform="ios",
     )
-    cmd.modules = IOS_CHECK_IOCS_MODULES
+    cmd.modules = BACKUP_MODULES + FS_MODULES + MIXED_MODULES
 
     if list_modules:
         cmd.list_modules()
@@ -508,8 +486,6 @@ def check_iocs(ctx, iocs, list_modules, module, load_module, folder):
 # ==============================================================================
 @cli.command("download-iocs", context_settings=CONTEXT_SETTINGS, help=HELP_MSG_STIX2)
 def download_iocs():
-    from mvt.common.updates import IndicatorsUpdates
-
     ioc_updates = IndicatorsUpdates()
     ioc_updates.update()
 

src/mvt/ios/command_modules.py

@@ -1,22 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2026 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-
-"""Module lists an mvt-ios command composes from more than one family.
-
-Commands whose modules are one family read that family directly. check-iocs
-re-checks stored results, so it has to know every module that could have
-written one, and both the CLI and any other code needing that answer share
-the list from here rather than each concatenating their own.
-"""
-
-from mvt.common.module import MVTModule
-
-from .modules.backup import BACKUP_MODULES
-from .modules.fs import FS_MODULES
-from .modules.mixed import MIXED_MODULES
-
-IOS_CHECK_IOCS_MODULES: list[type[MVTModule]] = (
-    BACKUP_MODULES + FS_MODULES + MIXED_MODULES
-)

src/mvt/plugin.py

@@ -1,80 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2026 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-
-"""Stable functions and modules which plugins can import.
-
-Anything else in mvt can be imported too, and may change
-between releases without notice.
-"""
-
-from mvt.android.modules.androidqf.base import AndroidQFModule
-from mvt.android.modules.backup.base import BackupModule as AndroidBackupModule
-from mvt.android.modules.bugreport.base import BugReportModule
-from mvt.common.alerts import Alert, AlertLevel
-from mvt.common.command import Command
-from mvt.common.config import settings
-from mvt.common.module import DatabaseCorruptedError, DatabaseNotFoundError, MVTModule
-from mvt.common.module_loader import get_plugin_logger
-from mvt.common.module_types import (
-    ModuleAtomicResult,
-    ModuleResults,
-    ModuleSerializedResult,
-)
-from mvt.common.plugin_config import (
-    MVTPluginSettings,
-    PluginConfigLoadError,
-    plugin_config_path,
-    plugin_data_folder,
-    plugin_env_prefix,
-)
-from mvt.common.utils import (
-    convert_chrometime_to_datetime,
-    convert_datetime_to_iso,
-    convert_mactime_to_datetime,
-    convert_mactime_to_iso,
-    convert_unix_to_iso,
-    convert_unix_to_utc_datetime,
-)
-from mvt.common.version import MVT_VERSION
-from mvt.ios.modules.base import IOSExtraction
-from mvt.ios.modules.sysdiagnose.base import SysdiagnoseExtraction
-
-__all__ = [
-    # Classes a plugin subclasses.
-    "MVTModule",
-    "IOSExtraction",
-    "SysdiagnoseExtraction",
-    "AndroidQFModule",
-    "AndroidBackupModule",
-    "BugReportModule",
-    "Command",
-    # Results and alerts.
-    "ModuleAtomicResult",
-    "ModuleResults",
-    "ModuleSerializedResult",
-    "Alert",
-    "AlertLevel",
-    # Errors a module raises.
-    "DatabaseNotFoundError",
-    "DatabaseCorruptedError",
-    # Settings.
-    "settings",
-    "MVTPluginSettings",
-    "PluginConfigLoadError",
-    "plugin_config_path",
-    "plugin_data_folder",
-    "plugin_env_prefix",
-    # Logging.
-    "get_plugin_logger",
-    # Timestamps.
-    "convert_chrometime_to_datetime",
-    "convert_datetime_to_iso",
-    "convert_mactime_to_datetime",
-    "convert_mactime_to_iso",
-    "convert_unix_to_iso",
-    "convert_unix_to_utc_datetime",
-    # MVT's version.
-    "MVT_VERSION",
-]

tests/android/test_artifact_tombstone_caused_by.py

@@ -1,54 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2023 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-"""A `Caused by:` line must not discard the whole text tombstone.
-
-Keys are matched as bare prefixes, so `Caused by: …` — an ordinary line inside
-an abort message — reached the `Cause` key, failed the key comparison and
-raised, which `Tombstones.run()` logged while dropping the entire crash record.
-Seen on a 1.6 MB tombstone whose protobuf twin was zero bytes: the crash then
-had no representation at all.
-"""
-
-import datetime
-
-from mvt.android.artifacts.tombstone_crashes import TombstoneCrashArtifact
-
-TOMBSTONE = b"""\
-*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
-Build fingerprint: 'Xiaomi/vili_eea/vili:13/TKQ1.220829.002/V14.0.10.0:user/release-keys'
-Revision: '0'
-ABI: 'arm64'
-Timestamp: 2023-08-24 14:54:47.999124034+0300
-Process uptime: 12199s
-Cmdline: com.example.game
-pid: 8044, tid: 26222, name: UnityMain  >>> com.example.game <<<
-uid: 10235
-signal 6 (SIGABRT), code -1 (SI_QUEUE), fault addr --------
-Abort message: 'No pending exception expected: java.lang.SecurityException: listen
-  at void android.os.Parcel.readException() (Parcel.java:2920)
-Caused by: android.os.RemoteException: Remote stack trace:
-\tat com.android.server.TelephonyRegistry.listen(TelephonyRegistry.java:1096)
-"""
-
-WITH_CAUSE = TOMBSTONE + b"Cause: null pointer dereference\n"
-
-
-class TestTombstoneCausedBy:
-    def _parse(self, content):
-        artifact = TombstoneCrashArtifact()
-        artifact.results = []
-        artifact.parse("tombstone_23", datetime.datetime(2023, 8, 24), content)
-        return artifact.results
-
-    def test_caused_by_line_does_not_discard_the_tombstone(self):
-        results = self._parse(TOMBSTONE)
-        assert len(results) == 1
-        assert results[0]["pid"] == 8044
-        assert results[0]["process_name"] == "UnityMain"
-        assert results[0]["uid"] == 10235
-
-    def test_the_real_cause_key_is_still_parsed(self):
-        results = self._parse(WITH_CAUSE)
-        assert results[0]["cause"] == "null pointer dereference"

tests/android/test_check_backup_optional_failure.py

@@ -1,39 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2023 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-"""An encrypted backup.ab must not take the whole check-androidqf run with it.
-
-`CmdAndroidCheckBackup.from_ab()` already raises `InvalidAndroidBackup` instead
-of exiting when it runs as a sub-command (`check-androidqf` catches that and
-skips the backup modules), for a wrong file format and for a parse error. The
-password branches used to call `sys.exit(1)` unconditionally, which ends the
-parent run inside `finish()` — before the intrusion-logs command and before the
-timeline, alerts, urls, info and run-manifest are written.
-"""
-
-import pytest
-
-from mvt.android.cmd_check_backup import CmdAndroidCheckBackup, InvalidAndroidBackup
-
-ENCRYPTED_AB_HEADER = b"ANDROID BACKUP\n5\n0\nAES-256\n" + b"\x00" * 64
-
-
-class TestCheckBackupOptionalFailure:
-    def _cmd(self, tmp_path, sub_command):
-        return CmdAndroidCheckBackup(
-            target_path=None,
-            results_path=str(tmp_path),
-            module_options={"interactive": False},
-            sub_command=sub_command,
-        )
-
-    def test_missing_password_raises_when_nested(self, tmp_path):
-        cmd = self._cmd(tmp_path, sub_command=True)
-        with pytest.raises(InvalidAndroidBackup):
-            cmd.from_ab(ENCRYPTED_AB_HEADER)
-
-    def test_missing_password_still_exits_on_its_own_command(self, tmp_path):
-        cmd = self._cmd(tmp_path, sub_command=False)
-        with pytest.raises(SystemExit):
-            cmd.from_ab(ENCRYPTED_AB_HEADER)

tests/common/test_cmd_check_iocs.py

@@ -1,225 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2026 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-
-import json
-import logging
-
-import pytest
-from click.testing import CliRunner
-
-from mvt.android.cli import cli as android_cli
-from mvt.android.command_modules import ANDROID_CHECK_IOCS_MODULES
-from mvt.common.cmd_check_iocs import CmdCheckIOCS
-from mvt.common.module import MVTModule
-from mvt.ios.cli import cli as ios_cli
-from mvt.ios.command_modules import IOS_CHECK_IOCS_MODULES
-from mvt.ios.modules.backup.manifest import Manifest
-
-# Keep the banner of the group callback from checking for updates online.
-OFFLINE = ["--disable-update-check", "--disable-indicator-update-check"]
-
-
-class CustomResultsModule(MVTModule):
-    """A custom module which declares the check-iocs pair of both platforms."""
-
-    slug = "custom_results"
-    supported_commands = (
-        ("ios", "check-backup"),
-        ("ios", "check-iocs"),
-        ("android", "check-iocs"),
-    )
-
-    checked: list = []
-
-    def run(self) -> None:
-        pass
-
-    def check_indicators(self) -> None:
-        self.checked.append(list(self.results))
-
-
-class BackupCheckerModule(MVTModule):
-    """An iOS module which implements check_indicators() without declaring check-iocs."""
-
-    slug = "backup_checker"
-    supported_commands = (("ios", "check-backup"),)
-
-    checked: list = []
-
-    def run(self) -> None:
-        pass
-
-    def check_indicators(self) -> None:
-        self.checked.append(list(self.results))
-
-
-class BugReportCheckerModule(MVTModule):
-    """The same for Android."""
-
-    slug = "bugreport_checker"
-    supported_commands = (("android", "check-bugreport"),)
-
-    checked: list = []
-
-    def run(self) -> None:
-        pass
-
-    def check_indicators(self) -> None:
-        self.checked.append(list(self.results))
-
-
-class BackupOnlyModule(MVTModule):
-    """A custom module which does not implement check_indicators()."""
-
-    slug = "backup_only"
-    supported_commands = (("ios", "check-backup"),)
-
-    def run(self) -> None:
-        pass
-
-
-@pytest.mark.parametrize(
-    "platform, builtin_modules, checker_module",
-    [
-        ("ios", IOS_CHECK_IOCS_MODULES, BackupCheckerModule),
-        ("android", ANDROID_CHECK_IOCS_MODULES, BugReportCheckerModule),
-    ],
-)
-def test_check_iocs_rechecks_the_stored_results_of_custom_modules(
-    platform, builtin_modules, checker_module, tmp_path, caplog
-):
-    # check-iocs matches every <slug>.json in the results folder to the module
-    # with that slug, custom modules included, and runs its check_indicators()
-    # again over the stored results.
-    results = [{"domain": "example.org"}]
-    (tmp_path / "custom_results.json").write_text(json.dumps(results))
-    (tmp_path / f"{checker_module.slug}.json").write_text(json.dumps(results))
-    (tmp_path / "backup_only.json").write_text(json.dumps(results))
-    CustomResultsModule.checked.clear()
-    checker_module.checked.clear()
-
-    cmd = CmdCheckIOCS(
-        target_path=str(tmp_path),
-        custom_modules=[CustomResultsModule, checker_module, BackupOnlyModule],
-        platform=platform,
-    )
-    cmd.modules = builtin_modules
-
-    with caplog.at_level(logging.INFO):
-        cmd.run()
-
-    # A module which declares the check-iocs pair is re-checked.
-    assert CustomResultsModule.checked == [results]
-    assert (
-        'Loading results from "custom_results.json" with module CustomResultsModule'
-        in caplog.text
-    )
-    # So is a module which only implements check_indicators().
-    assert checker_module.checked == [results]
-    # A module which does neither is not part of check-iocs.
-    assert "backup_only.json" not in caplog.text
-
-
-@pytest.mark.parametrize(
-    "platform, builtin_modules, listed, not_listed",
-    [
-        (
-            "ios",
-            IOS_CHECK_IOCS_MODULES,
-            "BackupCheckerModule",
-            "BugReportCheckerModule",
-        ),
-        (
-            "android",
-            ANDROID_CHECK_IOCS_MODULES,
-            "BugReportCheckerModule",
-            "BackupCheckerModule",
-        ),
-    ],
-)
-def test_check_iocs_lists_the_custom_modules_it_runs(
-    platform, builtin_modules, listed, not_listed, caplog
-):
-    cmd = CmdCheckIOCS(
-        custom_modules=[
-            CustomResultsModule,
-            BackupCheckerModule,
-            BugReportCheckerModule,
-            BackupOnlyModule,
-        ],
-        platform=platform,
-    )
-    cmd.modules = builtin_modules
-
-    with caplog.at_level(logging.INFO):
-        cmd.list_modules()
-
-    assert "CustomResultsModule" in caplog.text
-    # The module which implements check_indicators() for this platform is listed.
-    assert listed in caplog.text
-    # The one for the other platform is not, and neither is BackupOnlyModule.
-    assert not_listed not in caplog.text
-    assert "BackupOnlyModule" not in caplog.text
-
-
-class ReplacementManifest(Manifest):
-    """A replacement for a built-in module which does not declare check-iocs."""
-
-    supported_commands = (("ios", "check-backup"),)
-    replaces = Manifest
-
-
-def test_check_iocs_uses_a_replacement_of_a_built_in_module():
-    # A replacement which subclasses a built-in module inherits its
-    # check_indicators(). check-iocs then runs it in place of that module.
-    cmd = CmdCheckIOCS(custom_modules=[ReplacementManifest], platform="ios")
-    cmd.modules = IOS_CHECK_IOCS_MODULES
-
-    available = cmd._available_modules()
-
-    assert ReplacementManifest in available
-    assert Manifest not in available
-
-
-LOADED_MODULE = '''
-from mvt.common.module import MVTModule
-
-
-class LoadedResultsModule(MVTModule):
-    """A module loaded from a file with --load-module."""
-
-    slug = "loaded_results"
-    supported_commands = (("ios", "check-iocs"), ("android", "check-iocs"))
-
-    def run(self) -> None:
-        pass
-
-    def check_indicators(self) -> None:
-        self.log.warning("loaded module checked %d results", len(self.results))
-'''
-
-
-@pytest.mark.parametrize("cli", [ios_cli, android_cli], ids=["mvt-ios", "mvt-android"])
-def test_check_iocs_loads_custom_modules_from_a_file_on_each_cli(cli, tmp_path, caplog):
-    module_path = tmp_path / "loaded_module.py"
-    module_path.write_text(LOADED_MODULE)
-    results_folder = tmp_path / "results"
-    results_folder.mkdir()
-    (results_folder / "loaded_results.json").write_text(json.dumps([{"a": 1}]))
-
-    with caplog.at_level(logging.INFO):
-        result = CliRunner().invoke(
-            cli,
-            [
-                *OFFLINE,
-                "check-iocs",
-                "--load-module",
-                str(module_path),
-                str(results_folder),
-            ],
-        )
-
-    assert result.exit_code == 0, result.output
-    assert "loaded module checked 1 results" in caplog.text

tests/common/test_cmd_plugins.py

@@ -1,236 +0,0 @@
-import json
-from types import SimpleNamespace
-
-import pytest
-from click.testing import CliRunner
-
-from mvt.android.cli import cli as android_cli
-from mvt.cli import cli as mvt_cli
-from mvt.common.cli_plugins import (
-    ANDROID_CLI_PLUGIN_GROUP,
-    IOS_CLI_PLUGIN_GROUP,
-    NEUTRAL_CLI_PLUGIN_GROUP,
-)
-from mvt.common.cmd_plugins import plugins
-from mvt.common.module import MVTModule
-from mvt.common.module_loader import MODULES_ENTRY_POINT_GROUP
-from mvt.common.updates import PluginUpdates
-from mvt.ios.cli import cli as ios_cli
-
-
-class ExampleModule(MVTModule):
-    pass
-
-
-class AnotherModule(MVTModule):
-    pass
-
-
-class FakeDistribution:
-    def __init__(self, name, version="1.0.0", direct_url=None):
-        self.name = name
-        self.version = version
-        self.direct_url = direct_url
-
-    def read_text(self, file_name):
-        if file_name == "direct_url.json" and self.direct_url is not None:
-            return json.dumps(self.direct_url)
-        return None
-
-
-def _entry_point(name, distribution, modules=None, exception=None):
-    def load():
-        if exception is not None:
-            raise exception
-        return modules
-
-    return SimpleNamespace(
-        name=name, value="example_plugin:modules", dist=distribution, load=load
-    )
-
-
-def _run(command, arguments):
-    # Keep rich from wrapping the table while its content is being asserted.
-    return CliRunner().invoke(command, arguments, env={"COLUMNS": "200"})
-
-
-def _table_rows(output):
-    """Return the content of the table rows, without the header and the box."""
-    return [
-        [cell.strip() for cell in line.strip().strip("│").split("│")]
-        for line in output.splitlines()
-        if "│" in line
-    ]
-
-
-def _table_header(output):
-    for line in output.splitlines():
-        if "┃" in line:
-            return [cell.strip() for cell in line.strip().strip("┃").split("┃")]
-    return []
-
-
-def _install(monkeypatch, distributions, entry_points):
-    monkeypatch.setattr(
-        "mvt.common.cmd_plugins.installed_plugin_distributions",
-        lambda: distributions,
-    )
-    monkeypatch.setattr(
-        "mvt.common.cmd_plugins.importlib.metadata.entry_points",
-        lambda *, group: entry_points.get(group, []),
-    )
-
-
-def test_plugins_is_a_builtin_command_of_the_mvt_cli_only():
-    assert mvt_cli.commands["plugins"] is plugins
-    assert "plugins" not in ios_cli.commands
-    assert "plugins" not in android_cli.commands
-
-
-def test_list_shows_what_every_plugin_contributes(monkeypatch):
-    index_plugin = FakeDistribution("example-plugin", version="1.2.0")
-    repository_plugin = FakeDistribution(
-        "repository-plugin",
-        version="0.1.0",
-        direct_url={
-            "url": "https://example.org/plugin.git",
-            "vcs_info": {"vcs": "git", "commit_id": "b" * 40},
-        },
-    )
-    local_plugin = FakeDistribution(
-        "local-plugin",
-        direct_url={"url": "file:///plugins", "dir_info": {"editable": True}},
-    )
-    _install(
-        monkeypatch,
-        [index_plugin, local_plugin, repository_plugin],
-        {
-            MODULES_ENTRY_POINT_GROUP: [
-                _entry_point(
-                    "example", index_plugin, modules=[ExampleModule, AnotherModule]
-                ),
-                _entry_point("local", local_plugin, modules=lambda: [ExampleModule]),
-            ],
-            IOS_CLI_PLUGIN_GROUP: [_entry_point("summarize", repository_plugin)],
-            ANDROID_CLI_PLUGIN_GROUP: [_entry_point("triage", local_plugin)],
-            NEUTRAL_CLI_PLUGIN_GROUP: [_entry_point("report", repository_plugin)],
-        },
-    )
-
-    result = _run(plugins, ["list"])
-
-    assert result.exit_code == 0
-    # Plugins are listed by name, with the modules and the commands each of
-    # them contributes.
-    assert _table_header(result.output) == [
-        "Name",
-        "Version",
-        "Origin",
-        "Modules",
-        "Commands",
-    ]
-    assert _table_rows(result.output) == [
-        ["example-plugin", "1.2.0", "pypi", "2", "-"],
-        ["local-plugin", "1.0.0", "local", "1", "triage"],
-        ["repository-plugin", "0.1.0", "git+bbbbbbbb", "0", "report, summarize"],
-    ]
-
-
-def test_list_reports_a_broken_module_entry_point(monkeypatch):
-    plugin = FakeDistribution("broken-plugin")
-    _install(
-        monkeypatch,
-        [plugin],
-        {
-            MODULES_ENTRY_POINT_GROUP: [
-                _entry_point(
-                    "broken", plugin, exception=ImportError("missing dependency")
-                )
-            ]
-        },
-    )
-
-    result = _run(plugins, ["list"])
-
-    assert result.exit_code == 0
-    assert _table_rows(result.output) == [
-        ["broken-plugin", "1.0.0", "pypi", "error", "-"]
-    ]
-
-
-def test_list_without_plugins(monkeypatch):
-    _install(monkeypatch, [], {})
-
-    result = _run(plugins, ["list"])
-
-    assert result.exit_code == 0
-    assert result.output == "No MVT plugins are installed.\n"
-
-
-def test_check_updates_prints_the_findings_and_ignores_the_throttle(monkeypatch):
-    findings = [
-        {
-            "name": "example-plugin",
-            "installed": "1.0.0",
-            "latest": "1.2.0",
-            "origin": "pypi",
-            "upgrade_command": "pip install -U example-plugin",
-        }
-    ]
-    _install(monkeypatch, [FakeDistribution("example-plugin")], {})
-    monkeypatch.setattr(PluginUpdates, "check", lambda self: findings)
-    monkeypatch.setattr(
-        PluginUpdates,
-        "should_check",
-        lambda self: pytest.fail("an explicit check must not be throttled"),
-    )
-
-    result = _run(plugins, ["check-updates"])
-
-    assert result.exit_code == 0
-    assert "Plugin updates available:" in result.output
-    assert "example-plugin  1.0.0 → 1.2.0" in result.output
-    assert "Upgrade with: pip install -U example-plugin" in result.output
-    assert "MVT does not install plugin updates." in result.output
-
-
-def test_check_updates_without_available_updates(monkeypatch):
-    _install(monkeypatch, [FakeDistribution("example-plugin")], {})
-    monkeypatch.setattr(PluginUpdates, "check", lambda self: [])
-
-    result = _run(plugins, ["check-updates"])
-
-    assert result.exit_code == 0
-    assert "All plugins are up to date." in result.output
-
-
-def test_check_updates_without_plugins(monkeypatch):
-    _install(monkeypatch, [], {})
-    monkeypatch.setattr(
-        PluginUpdates,
-        "check",
-        lambda self: pytest.fail("nothing must be checked without plugins"),
-    )
-
-    result = _run(plugins, ["check-updates"])
-
-    assert result.exit_code == 0
-    assert "No MVT plugins are installed." in result.output
-
-
-def test_check_updates_without_network_access(monkeypatch):
-    monkeypatch.setattr("mvt.common.cmd_plugins.settings.NETWORK_ACCESS_ALLOWED", False)
-    monkeypatch.setattr(
-        "mvt.common.cmd_plugins.installed_plugin_distributions",
-        lambda: pytest.fail("plugins must not be listed without network access"),
-    )
-    monkeypatch.setattr(
-        PluginUpdates,
-        "check",
-        lambda self: pytest.fail("nothing must be checked without network access"),
-    )
-
-    result = _run(plugins, ["check-updates"])
-
-    assert result.exit_code == 0
-    assert "Network access is disabled" in result.output

tests/common/test_command.py

@@ -68,123 +68,6 @@ class CustomDependsOnBuiltin(RecordingModule):
     dependencies = (FirstModule,)
 
 
-class ReplacementModule(FirstModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = FirstModule
-
-    def run(self):
-        super().run()
-        self.results = ["replacement"]
-
-
-class OtherReplacementModule(FirstModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = FirstModule
-
-
-class UnrelatedReplacementModule(RecordingModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = IndependentModule
-
-
-class ReplacementOfReplacementModule(ReplacementModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = ReplacementModule
-
-    def run(self):
-        super().run()
-        self.results = ["replacement of replacement"]
-
-
-class ReplacesOwnDependencyModule(FirstModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = FirstModule
-    dependencies = (FirstModule,)
-
-
-class DisabledReplacementModule(FirstModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = FirstModule
-    enabled = False
-
-
-class MutualReplacementOne(RecordingModule):
-    supported_commands = (("ios", "check-backup"),)
-
-
-class MutualReplacementTwo(RecordingModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = MutualReplacementOne
-
-
-MutualReplacementOne.replaces = MutualReplacementTwo
-
-
-class CycleOneModule(RecordingModule):
-    supported_commands = (("ios", "check-backup"),)
-
-
-class CycleTwoModule(RecordingModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = CycleOneModule
-
-
-class CycleThreeModule(RecordingModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = CycleTwoModule
-
-
-CycleOneModule.replaces = CycleThreeModule
-
-
-class UnavailableDependencyModule(RecordingModule):
-    supported_commands = (("ios", "check-backup"),)
-
-
-class ReplacementMissingDependency(FirstModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = FirstModule
-    dependencies = (UnavailableDependencyModule,)
-
-
-class SharedSlugModule(RecordingModule):
-    supported_commands = (("ios", "check-backup"),)
-    slug = "shared_slug"
-
-
-class OtherSharedSlugModule(RecordingModule):
-    supported_commands = (("ios", "check-backup"),)
-    slug = "shared_slug"
-
-
-class ReplacementKeepingTheSlug(FirstModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = FirstModule
-    slug = "first_module"
-
-
-class SameNameReplacementModule(FirstModule):
-    supported_commands = (("ios", "check-backup"),)
-    replaces = FirstModule
-
-    def run(self):
-        super().run()
-        self.results = ["replacement"]
-
-
-# Modules replacing a built-in one usually keep its class name, which is the
-# name `--module` matches on.
-SameNameReplacementModule.__name__ = "FirstModule"
-
-
-def logged_substitutions(caplog) -> list[str]:
-    return [
-        record.getMessage()
-        for record in caplog.records
-        if record.levelno == logging.INFO and "replaces module" in record.getMessage()
-    ]
-
-
 class RecordingCommand(Command):
     def init(self):
         self.initialized = True
@@ -420,376 +303,3 @@ class TestCommand:
         cmd.run()
 
         assert RecordingModule.run_order == ["FirstModule", "CustomDependsOnBuiltin"]
-
-    def test_custom_module_replaces_builtin(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule, IndependentModule]
-        cmd.custom_modules = [ReplacementModule]
-
-        with caplog.at_level(logging.INFO):
-            cmd.run()
-
-        assert RecordingModule.run_order == ["IndependentModule", "ReplacementModule"]
-        assert cmd.module_replacements == {FirstModule: ReplacementModule}
-        assert (
-            "Module ReplacementModule from" in caplog.text
-            and "replaces module FirstModule" in caplog.text
-        )
-
-    def test_modules_without_replaces_all_run(self):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule]
-        cmd.custom_modules = [CustomIOSBackupModule]
-
-        cmd.run()
-
-        assert RecordingModule.run_order == ["FirstModule", "CustomIOSBackupModule"]
-        assert cmd.module_replacements == {}
-
-    def test_unavailable_replaced_module_is_ignored(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [IndependentModule]
-        cmd.custom_modules = [ReplacementModule]
-
-        with caplog.at_level(logging.INFO):
-            cmd.run()
-
-        assert RecordingModule.run_order == ["IndependentModule", "ReplacementModule"]
-        assert cmd.module_replacements == {}
-        assert "replaces module FirstModule" not in caplog.text
-
-    def test_dependencies_are_resolved_to_the_replacement(self):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [SecondModule, FirstModule]
-        cmd.custom_modules = [ReplacementModule]
-
-        cmd.run()
-
-        assert RecordingModule.run_order == ["ReplacementModule", "SecondModule"]
-        second = next(
-            module for module in cmd.executed if isinstance(module, SecondModule)
-        )
-        assert isinstance(second.dependency_modules[FirstModule], ReplacementModule)
-        assert second.results == ["replacement", "second"]
-
-    def test_replacement_with_unavailable_dependency_skips_its_dependents(
-        self, caplog
-    ):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule, SecondModule, IndependentModule]
-        cmd.custom_modules = [ReplacementMissingDependency]
-
-        with caplog.at_level(logging.INFO):
-            cmd.run()
-
-        # The replacement cannot run, and the module it replaced was dropped
-        # from the run by the replacement, so neither of them produces
-        # results and the module depending on the replaced one is skipped.
-        assert RecordingModule.run_order == ["IndependentModule"]
-        assert (
-            "Module ReplacementMissingDependency will be SKIPPED: it depends "
-            "on module UnavailableDependencyModule, which is not available in "
-            "this command." in caplog.text
-        )
-        # The skipped dependent is told which module it actually depends on,
-        # and the module class its author declared.
-        assert (
-            "Module SecondModule will be SKIPPED: it depends on module "
-            "ReplacementMissingDependency (replacing module FirstModule), "
-            "itself skipped for depending on unavailable module "
-            "UnavailableDependencyModule." in caplog.text
-        )
-
-    def test_selected_replacement_with_unavailable_dependency_runs_nothing(
-        self, caplog, tmp_path
-    ):
-        cmd = RecordingCommand(module_name="FirstModule", results_path=str(tmp_path))
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule, IndependentModule]
-        cmd.custom_modules = [ReplacementMissingDependency]
-
-        with caplog.at_level(logging.INFO):
-            cmd.run()
-
-        assert RecordingModule.run_order == []
-        assert not hasattr(cmd, "initialized")
-        assert (
-            "Module FirstModule was replaced by module "
-            "ReplacementMissingDependency, which is run in its place."
-            in caplog.text
-        )
-        assert "Module ReplacementMissingDependency will be SKIPPED" in caplog.text
-        assert "No modules will be run" in caplog.text
-        # Nothing else was selected, so the warnings must not promise that the
-        # analysis continues right before saying that it does not.
-        assert "The rest of the analysis will still run" not in caplog.text
-        # No module ran, so no results were stored next to the command log.
-        assert [path.name for path in tmp_path.iterdir()] == ["command.log"]
-
-    def test_chained_replacements_are_resolved(self):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [SecondModule, FirstModule]
-        cmd.custom_modules = [ReplacementModule, ReplacementOfReplacementModule]
-
-        cmd.run()
-
-        assert RecordingModule.run_order == [
-            "ReplacementOfReplacementModule",
-            "SecondModule",
-        ]
-        second = next(
-            module for module in cmd.executed if isinstance(module, SecondModule)
-        )
-        assert second.results == ["replacement of replacement", "second"]
-
-    def test_replacement_which_is_not_a_subclass_warns(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [IndependentModule]
-        cmd.custom_modules = [UnrelatedReplacementModule]
-
-        with caplog.at_level(logging.WARNING):
-            cmd.run()
-
-        assert RecordingModule.run_order == ["UnrelatedReplacementModule"]
-        assert "is not a subclass of it" in caplog.text
-
-    def test_multiple_modules_replacing_the_same_module_warn(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule]
-        cmd.custom_modules = [ReplacementModule, OtherReplacementModule]
-
-        with caplog.at_level(logging.WARNING):
-            cmd.run()
-
-        assert RecordingModule.run_order == [
-            "ReplacementModule",
-            "OtherReplacementModule",
-        ]
-        assert cmd.module_replacements == {FirstModule: ReplacementModule}
-        assert (
-            "Modules ReplacementModule and OtherReplacementModule both replace "
-            "module FirstModule. Both of them will run, FirstModule will not, "
-            "and modules depending on FirstModule will use the results of "
-            "ReplacementModule." in caplog.text
-        )
-        assert "overwrite each other's results file" in caplog.text
-
-    def test_module_replacing_its_own_dependency_runs(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule]
-        cmd.custom_modules = [ReplacesOwnDependencyModule]
-
-        with caplog.at_level(logging.WARNING):
-            cmd.run()
-
-        assert RecordingModule.run_order == ["ReplacesOwnDependencyModule"]
-        assert (
-            "Module ReplacesOwnDependencyModule depends on module FirstModule, "
-            "which it also replaces" in caplog.text
-        )
-
-    def test_literal_self_dependency_is_still_circular(self, caplog):
-        class SelfDependentModule(RecordingModule):
-            pass
-
-        SelfDependentModule.dependencies = (SelfDependentModule,)
-
-        cmd = RecordingCommand()
-        cmd.modules = [SelfDependentModule]
-
-        with caplog.at_level(logging.WARNING):
-            cmd.run()
-
-        assert RecordingModule.run_order == []
-        assert not hasattr(cmd, "initialized")
-        assert "Circular module dependency detected" in caplog.text
-
-    def test_disabled_replacement_keeps_the_replaced_module(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule]
-        cmd.custom_modules = [DisabledReplacementModule]
-
-        with caplog.at_level(logging.INFO):
-            cmd.run()
-
-        assert RecordingModule.run_order == ["FirstModule"]
-        assert cmd.module_replacements == {}
-        assert logged_substitutions(caplog) == []
-
-    def test_modules_replacing_each_other_all_run(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.custom_modules = [MutualReplacementOne, MutualReplacementTwo]
-
-        with caplog.at_level(logging.INFO):
-            cmd.run()
-
-        assert RecordingModule.run_order == [
-            "MutualReplacementOne",
-            "MutualReplacementTwo",
-        ]
-        assert cmd.module_replacements == {}
-        assert (
-            "Modules MutualReplacementOne, MutualReplacementTwo replace each "
-            "other in a cycle" in caplog.text
-        )
-        assert logged_substitutions(caplog) == []
-
-    def test_replacement_cycle_of_three_modules_all_run(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.custom_modules = [CycleOneModule, CycleTwoModule, CycleThreeModule]
-
-        with caplog.at_level(logging.INFO):
-            cmd.run()
-
-        assert RecordingModule.run_order == [
-            "CycleOneModule",
-            "CycleTwoModule",
-            "CycleThreeModule",
-        ]
-        assert cmd.module_replacements == {}
-        assert (
-            "Modules CycleOneModule, CycleThreeModule, CycleTwoModule replace "
-            "each other in a cycle" in caplog.text
-        )
-        assert logged_substitutions(caplog) == []
-
-    def test_selected_replaced_module_name_runs_the_replacement(self, caplog):
-        cmd = RecordingCommand(module_name="FirstModule")
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule]
-        cmd.custom_modules = [ReplacementModule]
-
-        with caplog.at_level(logging.INFO):
-            cmd.run()
-
-        assert RecordingModule.run_order == ["ReplacementModule"]
-        assert (
-            "Module FirstModule was replaced by module ReplacementModule"
-            in caplog.text
-        )
-
-    def test_unknown_selected_module_warns_and_stops(self, caplog):
-        cmd = RecordingCommand(module_name="NoSuchModule")
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule]
-
-        with caplog.at_level(logging.WARNING):
-            cmd.run()
-
-        assert RecordingModule.run_order == []
-        assert not hasattr(cmd, "initialized")
-        assert (
-            "No module named NoSuchModule is available for the check-backup "
-            "command" in caplog.text
-        )
-
-    def test_selected_module_name_matches_the_replacement(self):
-        cmd = RecordingCommand(module_name="FirstModule")
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule]
-        cmd.custom_modules = [SameNameReplacementModule]
-
-        cmd.run()
-
-        assert len(cmd.executed) == 1
-        assert isinstance(cmd.executed[0], SameNameReplacementModule)
-        assert cmd.executed[0].results == ["replacement"]
-
-    def test_list_modules_reflects_replacements(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule, IndependentModule]
-        cmd.custom_modules = [ReplacementModule]
-
-        with caplog.at_level(logging.INFO):
-            cmd.list_modules()
-
-        listed = [
-            record.getMessage()
-            for record in caplog.records
-            if "Modules from" in record.getMessage()
-        ]
-        assert any("ReplacementModule" in message for message in listed)
-        assert not any("FirstModule" in message for message in listed)
-
-    def test_modules_sharing_a_slug_are_reported(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.custom_modules = [SharedSlugModule, OtherSharedSlugModule]
-
-        with caplog.at_level(logging.WARNING):
-            cmd.run()
-
-        assert RecordingModule.run_order == [
-            "SharedSlugModule",
-            "OtherSharedSlugModule",
-        ]
-        collisions = [
-            record.getMessage()
-            for record in caplog.records
-            if "both use the slug" in record.getMessage()
-        ]
-        assert len(collisions) == 1
-        assert "Modules SharedSlugModule from" in collisions[0]
-        assert "and OtherSharedSlugModule from" in collisions[0]
-        assert "both use the slug shared_slug" in collisions[0]
-        assert "overwrites the results of the other in shared_slug.json" in (
-            collisions[0]
-        )
-
-    def test_replacement_keeping_the_replaced_slug_is_not_reported(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule]
-        cmd.custom_modules = [ReplacementKeepingTheSlug]
-
-        with caplog.at_level(logging.WARNING):
-            cmd.run()
-
-        # The replaced module is no longer part of the run, so taking over its
-        # slug is what the replacement is for, not a collision.
-        assert RecordingModule.run_order == ["ReplacementKeepingTheSlug"]
-        assert ReplacementKeepingTheSlug.get_slug() == FirstModule.get_slug()
-        assert "both use the slug" not in caplog.text
-
-    def test_modules_with_distinct_slugs_are_not_reported(self, caplog):
-        cmd = RecordingCommand()
-        cmd.platform = "ios"
-        cmd.name = "check-backup"
-        cmd.modules = [FirstModule, IndependentModule]
-        cmd.custom_modules = [CustomIOSBackupModule]
-
-        with caplog.at_level(logging.WARNING):
-            cmd.run()
-
-        assert "both use the slug" not in caplog.text

tests/common/test_command_modules.py

@@ -1,27 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2026 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-
-from mvt.android.command_modules import ANDROID_CHECK_IOCS_MODULES
-from mvt.android.modules.androidqf import ANDROIDQF_MODULES
-from mvt.android.modules.backup import BACKUP_MODULES as ANDROID_BACKUP_MODULES
-from mvt.android.modules.bugreport import BUGREPORT_MODULES
-from mvt.android.modules.intrusion_logs import INTRUSION_LOGS_MODULES
-from mvt.ios.command_modules import IOS_CHECK_IOCS_MODULES
-from mvt.ios.modules.backup import BACKUP_MODULES as IOS_BACKUP_MODULES
-from mvt.ios.modules.fs import FS_MODULES
-from mvt.ios.modules.mixed import MIXED_MODULES
-
-
-def test_the_check_iocs_lists_are_the_families_of_their_platform():
-    # The CLI reads these same lists, so nothing composing one elsewhere can
-    # drift from what the command runs. This pins what the lists are composed
-    # of.
-    assert IOS_CHECK_IOCS_MODULES == IOS_BACKUP_MODULES + FS_MODULES + MIXED_MODULES
-    assert ANDROID_CHECK_IOCS_MODULES == (
-        ANDROID_BACKUP_MODULES
-        + BUGREPORT_MODULES
-        + ANDROIDQF_MODULES
-        + INTRUSION_LOGS_MODULES
-    )

tests/common/test_module_loader.py

@@ -1,14 +1,9 @@
-from pathlib import Path
-
 import pytest
 
-from mvt.common.cli_plugins import _module_name_for_path as _command_module_name
 from mvt.common.module import MVTModule
 from mvt.common.module_loader import (
     CustomModuleLoadError,
-    _module_name_for_path,
     get_module_logger,
-    get_plugin_logger,
     load_custom_modules,
     load_custom_modules_from_path,
     module_supports_command,
@@ -173,9 +168,9 @@ def test_get_module_logger_strips_the_plugin_package_prefix():
     class PluginModule(MVTModule):
         pass
 
-    PluginModule.__module__ = "mvt_plugin_example_org.ios.custom"
+    PluginModule.__module__ = "mvt_plugin_amnesty_custom.ios.custom"
 
-    assert get_module_logger(PluginModule).name == "mvt.ext.example_org.ios.custom"
+    assert get_module_logger(PluginModule).name == "mvt.ext.amnesty_custom.ios.custom"
 
 
 def test_get_module_logger_only_strips_the_prefix_from_the_top_level():
@@ -192,25 +187,3 @@ def test_get_module_logger_names_path_modules_after_their_file(tmp_path):
     module = load_custom_modules_from_path(str(module_path))[0]
 
     assert get_module_logger(module).name == "mvt.ext.my_custom_module"
-
-
-def test_get_plugin_logger_uses_the_same_namespace_as_modules():
-    assert (
-        get_plugin_logger("mvt_plugin_example_org.commands.summarize").name
-        == "mvt.ext.example_org.commands.summarize"
-    )
-    assert get_plugin_logger("example_plugin.cli").name == "mvt.ext.example_plugin.cli"
-
-
-def test_get_plugin_logger_keeps_builtin_names():
-    assert get_plugin_logger("mvt.ios.cli").name == "mvt.ios.cli"
-
-
-def test_get_plugin_logger_names_loaded_files_after_the_file():
-    # A file loaded with --load-command or --load-module is imported under a
-    # mangled name. The log names the file instead.
-    command_name = _command_module_name(Path("/tmp/case_summary.py"))
-    module_name = _module_name_for_path(Path("/tmp/my_custom_module.py"))
-
-    assert get_plugin_logger(command_name).name == "mvt.ext.case_summary"
-    assert get_plugin_logger(module_name).name == "mvt.ext.my_custom_module"

tests/common/test_plugin.py

@@ -1,34 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2026 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-
-import mvt.plugin
-from mvt.android.modules.backup.base import BackupModule
-from mvt.common.config import settings
-
-from ..plugin_fixtures import run_isolated_python
-
-
-def test_the_exported_names_are_the_public_names():
-    public = {name for name in vars(mvt.plugin) if not name.startswith("_")}
-
-    assert public == set(mvt.plugin.__all__)
-    assert mvt.plugin.settings is settings
-    assert mvt.plugin.AndroidBackupModule is BackupModule
-
-
-def test_the_surface_imports_before_anything_else_of_mvt(tmp_path):
-    # A plugin can import the surface as its first import of MVT. The
-    # subprocess gets a temporary home because importing MVT writes its
-    # configuration file.
-    result = run_isolated_python(
-        "from mvt.plugin import IOSExtraction, MVT_VERSION, settings\n"
-        "assert MVT_VERSION\n"
-        "assert settings.NETWORK_TIMEOUT > 0\n"
-        "assert IOSExtraction.__name__ == 'IOSExtraction'\n",
-        home=tmp_path,
-    )
-
-    assert result.returncode == 0, result.stderr
-    assert result.stderr == ""

tests/common/test_plugin_updates.py

@@ -1,711 +0,0 @@
-import json
-import shlex
-from datetime import datetime, timedelta
-from types import SimpleNamespace
-
-import pytest
-
-from mvt.common import logo
-from mvt.common.cli_plugins import (
-    ANDROID_CLI_PLUGIN_GROUP,
-    IOS_CLI_PLUGIN_GROUP,
-    NEUTRAL_CLI_PLUGIN_GROUP,
-)
-from mvt.common.module_loader import MODULES_ENTRY_POINT_GROUP
-from mvt.common.updates import (
-    MVTUpdates,
-    PluginUpdates,
-    installed_plugin_distributions,
-)
-
-
-REPOSITORY_URL = "https://example.org/plugin.git"
-INSTALLED_COMMIT = "a" * 40
-REMOTE_COMMIT = "b" * 40
-
-
-class FakeDistribution:
-    def __init__(self, name, version="1.0.0", direct_url=None):
-        self.name = name
-        self.version = version
-        self.direct_url = direct_url
-
-    def read_text(self, file_name):
-        if file_name == "direct_url.json" and self.direct_url is not None:
-            return json.dumps(self.direct_url)
-        return None
-
-
-class FakeResponse:
-    def __init__(self, status_code=200, payload=None):
-        self.status_code = status_code
-        self.payload = payload or {}
-
-    def json(self):
-        return self.payload
-
-
-def _entry_point(name, distribution, value="plugin:modules"):
-    return SimpleNamespace(name=name, value=value, dist=distribution)
-
-
-def _git_distribution(requested_revision=None, commit=INSTALLED_COMMIT):
-    vcs_info = {"vcs": "git", "commit_id": commit}
-    if requested_revision:
-        vcs_info["requested_revision"] = requested_revision
-
-    return FakeDistribution(
-        "example-plugin",
-        direct_url={"url": REPOSITORY_URL, "vcs_info": vcs_info},
-    )
-
-
-def _fake_git(stdout="", returncode=0, exception=None, calls=None):
-    def run(command, **kwargs):
-        if calls is not None:
-            calls.append((command, kwargs))
-        if exception is not None:
-            raise exception
-        return SimpleNamespace(returncode=returncode, stdout=stdout, stderr="")
-
-    return run
-
-
-@pytest.fixture
-def data_folder(tmp_path, monkeypatch):
-    folder = tmp_path / "mvt-data"
-    monkeypatch.setattr("mvt.common.updates.MVT_DATA_FOLDER", str(folder))
-    return folder
-
-
-@pytest.fixture
-def one_plugin(monkeypatch):
-    def install(distribution):
-        monkeypatch.setattr(
-            "mvt.common.updates.installed_plugin_distributions",
-            lambda: [distribution],
-        )
-        return distribution
-
-    return install
-
-
-def test_installed_plugin_distributions_covers_every_plugin_group(monkeypatch):
-    zeta = FakeDistribution("zeta-plugin")
-    alpha = FakeDistribution("alpha-plugin")
-    neutral = FakeDistribution("neutral-plugin")
-
-    def entry_points(*, group):
-        if group == MODULES_ENTRY_POINT_GROUP:
-            return [_entry_point("zeta", zeta), _entry_point("alpha", alpha)]
-        if group == IOS_CLI_PLUGIN_GROUP:
-            return [_entry_point("zeta-ios", zeta)]
-        if group == ANDROID_CLI_PLUGIN_GROUP:
-            return [_entry_point("alpha-android", alpha)]
-        if group == NEUTRAL_CLI_PLUGIN_GROUP:
-            return [_entry_point("shared", neutral)]
-        return []
-
-    monkeypatch.setattr(
-        "mvt.common.updates.importlib.metadata.entry_points", entry_points
-    )
-
-    distributions = installed_plugin_distributions()
-
-    assert [distribution.name for distribution in distributions] == [
-        "alpha-plugin",
-        "neutral-plugin",
-        "zeta-plugin",
-    ]
-
-
-def test_installed_plugin_distributions_skips_mvt_and_orphan_entry_points(monkeypatch):
-    entry_points = [
-        _entry_point("builtin", FakeDistribution("mvt")),
-        SimpleNamespace(name="orphan", value="plugin:modules", dist=None),
-        _entry_point("plugin", FakeDistribution("example-plugin")),
-    ]
-    monkeypatch.setattr(
-        "mvt.common.updates.importlib.metadata.entry_points",
-        lambda **kwargs: entry_points,
-    )
-
-    distributions = installed_plugin_distributions()
-
-    assert [distribution.name for distribution in distributions] == ["example-plugin"]
-
-
-def test_installed_plugin_distributions_survives_broken_metadata(monkeypatch, caplog):
-    def entry_points(*, group):
-        raise RuntimeError("invalid package metadata")
-
-    monkeypatch.setattr(
-        "mvt.common.updates.importlib.metadata.entry_points", entry_points
-    )
-
-    assert installed_plugin_distributions() == []
-    assert "Unable to discover installed plugin packages" in caplog.text
-
-
-def test_index_plugin_update_is_reported(monkeypatch, data_folder, one_plugin):
-    one_plugin(FakeDistribution("example-plugin", version="1.0.0"))
-    monkeypatch.setattr(
-        "mvt.common.updates.requests.get",
-        lambda url, **kwargs: FakeResponse(payload={"info": {"version": "1.2.0"}}),
-    )
-
-    findings = PluginUpdates().check()
-
-    assert findings == [
-        {
-            "name": "example-plugin",
-            "installed": "1.0.0",
-            "latest": "1.2.0",
-            "origin": "pypi",
-            "upgrade_command": "pip install -U example-plugin",
-        }
-    ]
-
-
-def test_index_plugin_queries_the_package_index_with_the_configured_timeout(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(FakeDistribution("example-plugin"))
-    requests_made = []
-
-    def get(url, **kwargs):
-        requests_made.append((url, kwargs))
-        return FakeResponse(payload={"info": {"version": "1.0.0"}})
-
-    monkeypatch.setattr("mvt.common.updates.requests.get", get)
-    monkeypatch.setattr("mvt.common.updates.settings.NETWORK_TIMEOUT", 3)
-
-    PluginUpdates().check()
-
-    assert requests_made == [
-        ("https://pypi.org/pypi/example-plugin/json", {"timeout": 3})
-    ]
-
-
-def test_up_to_date_index_plugin_is_not_reported(monkeypatch, data_folder, one_plugin):
-    one_plugin(FakeDistribution("example-plugin", version="1.2.0"))
-    monkeypatch.setattr(
-        "mvt.common.updates.requests.get",
-        lambda url, **kwargs: FakeResponse(payload={"info": {"version": "1.2.0"}}),
-    )
-
-    assert PluginUpdates().check() == []
-
-
-def test_unpublished_plugin_is_skipped_silently(monkeypatch, data_folder, one_plugin):
-    one_plugin(FakeDistribution("private-plugin"))
-    monkeypatch.setattr(
-        "mvt.common.updates.requests.get",
-        lambda url, **kwargs: FakeResponse(status_code=404),
-    )
-
-    assert PluginUpdates().check() == []
-
-
-def test_repository_plugin_following_a_branch_is_reported(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(_git_distribution(requested_revision="main"))
-    calls = []
-    monkeypatch.setattr(
-        "mvt.common.updates.subprocess.run",
-        _fake_git(stdout=f"{REMOTE_COMMIT}\trefs/heads/main\n", calls=calls),
-    )
-    monkeypatch.delenv("GIT_SSH_COMMAND", raising=False)
-
-    findings = PluginUpdates().check()
-
-    assert findings == [
-        {
-            "name": "example-plugin",
-            "installed": "aaaaaaaa",
-            "latest": "bbbbbbbb",
-            "origin": "git",
-            "upgrade_command": (
-                f"pip install -U 'example-plugin @ git+{REPOSITORY_URL}@main'"
-            ),
-        }
-    ]
-    command, options = calls[0]
-    assert command == ["git", "ls-remote", REPOSITORY_URL, "main"]
-    assert options["env"]["GIT_TERMINAL_PROMPT"] == "0"
-    # ssh asks the terminal for a passphrase or a host key unless it is told
-    # not to, which git itself cannot prevent.
-    assert options["env"]["GIT_SSH_COMMAND"] == (
-        "ssh -o BatchMode=yes -o ConnectTimeout=10"
-    )
-
-
-def test_batch_mode_options_come_before_the_configured_ssh_options(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(_git_distribution(requested_revision="main"))
-    calls = []
-    monkeypatch.setattr(
-        "mvt.common.updates.subprocess.run",
-        _fake_git(stdout=f"{REMOTE_COMMIT}\trefs/heads/main\n", calls=calls),
-    )
-    monkeypatch.setenv("GIT_SSH_COMMAND", "ssh -o BatchMode=no -i /home/analyst/key")
-
-    PluginUpdates().check()
-
-    # ssh uses the first value it is given for a keyword, so an analyst asking
-    # for prompts cannot bring them back, while their other options still
-    # apply.
-    assert calls[0][1]["env"]["GIT_SSH_COMMAND"] == (
-        "ssh -o BatchMode=yes -o ConnectTimeout=10 -o BatchMode=no -i /home/analyst/key"
-    )
-
-
-def test_repository_plugin_without_a_revision_follows_the_default_branch(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(_git_distribution())
-    calls = []
-    monkeypatch.setattr(
-        "mvt.common.updates.subprocess.run",
-        _fake_git(stdout=f"{REMOTE_COMMIT}\tHEAD\n", calls=calls),
-    )
-
-    findings = PluginUpdates().check()
-
-    assert calls[0][0] == ["git", "ls-remote", REPOSITORY_URL, "HEAD"]
-    assert findings[0]["upgrade_command"] == (
-        f"pip install -U 'example-plugin @ git+{REPOSITORY_URL}'"
-    )
-
-
-def test_hostile_revision_cannot_inject_into_the_upgrade_command(
-    monkeypatch, data_folder, one_plugin
-):
-    revision = "main$(id)`id`;id"
-    one_plugin(_git_distribution(requested_revision=revision))
-    monkeypatch.setattr(
-        "mvt.common.updates.subprocess.run",
-        _fake_git(stdout=f"{REMOTE_COMMIT}\trefs/heads/{revision}\n"),
-    )
-
-    upgrade_command = PluginUpdates().check()[0]["upgrade_command"]
-
-    # Single quotes are the only quoting a shell does not expand anything in.
-    assert upgrade_command == (
-        f"pip install -U 'example-plugin @ git+{REPOSITORY_URL}@{revision}'"
-    )
-    assert shlex.split(upgrade_command) == [
-        "pip",
-        "install",
-        "-U",
-        f"example-plugin @ git+{REPOSITORY_URL}@{revision}",
-    ]
-
-
-def test_repository_plugin_with_an_option_like_url_is_skipped(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(
-        FakeDistribution(
-            "example-plugin",
-            direct_url={
-                "url": "--upload-pack=touch /tmp/mvt",
-                "vcs_info": {"vcs": "git", "commit_id": INSTALLED_COMMIT},
-            },
-        )
-    )
-    calls = []
-    monkeypatch.setattr("mvt.common.updates.subprocess.run", _fake_git(calls=calls))
-
-    assert PluginUpdates().check() == []
-    assert calls == []
-
-
-def test_repository_plugin_with_an_option_like_revision_is_skipped(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(_git_distribution(requested_revision="--upload-pack=touch /tmp/mvt"))
-    calls = []
-    monkeypatch.setattr("mvt.common.updates.subprocess.run", _fake_git(calls=calls))
-
-    assert PluginUpdates().check() == []
-    assert calls == []
-
-
-def test_repository_plugin_at_the_latest_commit_is_not_reported(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(_git_distribution(requested_revision="main"))
-    monkeypatch.setattr(
-        "mvt.common.updates.subprocess.run",
-        _fake_git(stdout=f"{INSTALLED_COMMIT}\trefs/heads/main\n"),
-    )
-
-    assert PluginUpdates().check() == []
-
-
-def test_commit_pinned_repository_plugin_is_never_outdated(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(_git_distribution(requested_revision=INSTALLED_COMMIT))
-    calls = []
-    monkeypatch.setattr("mvt.common.updates.subprocess.run", _fake_git(calls=calls))
-
-    assert PluginUpdates().check() == []
-    assert calls == []
-
-
-def test_short_commit_pinned_repository_plugin_is_never_outdated(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(_git_distribution(requested_revision=INSTALLED_COMMIT[:10]))
-    calls = []
-    monkeypatch.setattr("mvt.common.updates.subprocess.run", _fake_git(calls=calls))
-
-    assert PluginUpdates().check() == []
-    assert calls == []
-
-
-def test_tag_pinned_repository_plugin_is_never_outdated(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(_git_distribution(requested_revision="v1.0.0"))
-    monkeypatch.setattr(
-        "mvt.common.updates.subprocess.run",
-        _fake_git(stdout=f"{REMOTE_COMMIT}\trefs/tags/v1.0.0\n"),
-    )
-
-    assert PluginUpdates().check() == []
-
-
-def test_repository_plugin_is_skipped_without_git(monkeypatch, data_folder, one_plugin):
-    one_plugin(_git_distribution(requested_revision="main"))
-    monkeypatch.setattr(
-        "mvt.common.updates.subprocess.run",
-        _fake_git(exception=FileNotFoundError("git")),
-    )
-
-    assert PluginUpdates().check() == []
-
-
-def test_repository_plugin_is_skipped_when_git_fails(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(_git_distribution(requested_revision="main"))
-    monkeypatch.setattr(
-        "mvt.common.updates.subprocess.run",
-        _fake_git(stdout="", returncode=128),
-    )
-
-    assert PluginUpdates().check() == []
-
-
-def test_local_plugin_install_is_skipped(monkeypatch, data_folder, one_plugin):
-    one_plugin(
-        FakeDistribution(
-            "example-plugin",
-            direct_url={
-                "url": "file:///home/analyst/example-plugin",
-                "dir_info": {"editable": True},
-            },
-        )
-    )
-
-    def fail(*args, **kwargs):
-        raise AssertionError("a local plugin install must not be checked")
-
-    monkeypatch.setattr("mvt.common.updates.requests.get", fail)
-    monkeypatch.setattr("mvt.common.updates.subprocess.run", fail)
-
-    assert PluginUpdates().check() == []
-
-
-def test_check_stores_the_findings_and_the_check_timestamp(
-    monkeypatch, data_folder, one_plugin
-):
-    one_plugin(FakeDistribution("example-plugin", version="1.0.0"))
-    monkeypatch.setattr(
-        "mvt.common.updates.requests.get",
-        lambda url, **kwargs: FakeResponse(payload={"info": {"version": "1.2.0"}}),
-    )
-    plugin_updates = PluginUpdates()
-
-    findings = plugin_updates.check()
-
-    assert json.loads((data_folder / "plugin_updates.json").read_text()) == findings
-    assert (data_folder / "latest_plugins_check").read_text().isdigit()
-    assert PluginUpdates().get_findings() == findings
-
-
-def test_findings_are_empty_before_the_first_check(data_folder):
-    assert PluginUpdates().get_findings() == []
-
-
-def test_malformed_cached_findings_are_dropped(data_folder):
-    plugin_updates = PluginUpdates()
-    usable = {
-        "name": "example-plugin",
-        "installed": "1.0.0",
-        "latest": "1.2.0",
-        "origin": "pypi",
-        "upgrade_command": "pip install -U example-plugin",
-    }
-    data_folder.mkdir(parents=True, exist_ok=True)
-    (data_folder / "plugin_updates.json").write_text(
-        json.dumps(
-            [
-                {"oops": 1},
-                "not a finding",
-                {"name": "half-plugin", "installed": "1.0.0"},
-                {**usable, "latest": None},
-                usable,
-            ]
-        ),
-        encoding="utf-8",
-    )
-
-    assert plugin_updates.get_findings() == [usable]
-
-
-def test_corrupt_cached_findings_are_ignored(data_folder):
-    data_folder.mkdir(parents=True, exist_ok=True)
-    (data_folder / "plugin_updates.json").write_text("{ not json", encoding="utf-8")
-
-    assert PluginUpdates().get_findings() == []
-
-
-def test_cached_findings_of_upgraded_and_removed_plugins_are_dropped(
-    monkeypatch, data_folder
-):
-    findings = [
-        {
-            "name": "upgraded-plugin",
-            "installed": "1.0.0",
-            "latest": "1.2.0",
-            "origin": "pypi",
-            "upgrade_command": "pip install -U upgraded-plugin",
-        },
-        {
-            "name": "removed-plugin",
-            "installed": "1.0.0",
-            "latest": "1.2.0",
-            "origin": "pypi",
-            "upgrade_command": "pip install -U removed-plugin",
-        },
-        {
-            "name": "example-plugin",
-            "installed": "1.0.0",
-            "latest": "1.2.0",
-            "origin": "pypi",
-            "upgrade_command": "pip install -U example-plugin",
-        },
-    ]
-    plugin_updates = PluginUpdates()
-    plugin_updates.set_findings(findings)
-    monkeypatch.setattr(
-        "mvt.common.updates.installed_plugin_distributions",
-        lambda: [
-            # The analyst upgraded this plugin since the latest check.
-            FakeDistribution("upgraded-plugin", version="1.2.0"),
-            FakeDistribution("example-plugin", version="1.0.0"),
-        ],
-    )
-
-    assert plugin_updates.current_findings() == [findings[2]]
-
-
-def test_cached_findings_of_updated_repository_plugins_are_dropped(data_folder):
-    findings = [
-        {
-            "name": "example-plugin",
-            "installed": "aaaaaaaa",
-            "latest": "bbbbbbbb",
-            "origin": "git",
-            "upgrade_command": "pip install -U example-plugin",
-        }
-    ]
-    plugin_updates = PluginUpdates()
-    plugin_updates.set_findings(findings)
-
-    assert plugin_updates.current_findings([_git_distribution()]) == findings
-    assert (
-        plugin_updates.current_findings([_git_distribution(commit=REMOTE_COMMIT)]) == []
-    )
-
-
-def test_corrupt_check_timestamp_does_not_raise(data_folder):
-    plugin_updates = PluginUpdates()
-    data_folder.mkdir(parents=True, exist_ok=True)
-    (data_folder / "latest_plugins_check").write_text("truncated", encoding="utf-8")
-
-    assert plugin_updates.get_latest_check() == 0
-    assert plugin_updates.should_check() == (True, 0)
-
-
-def test_should_check_is_throttled_for_twelve_hours(data_folder):
-    plugin_updates = PluginUpdates()
-    plugin_updates.set_findings([])
-
-    recent = datetime.now() - timedelta(hours=4)
-    with open(plugin_updates.latest_check_path, "w", encoding="utf-8") as handle:
-        handle.write(str(int(recent.timestamp())))
-
-    should_check, hours = plugin_updates.should_check()
-    assert not should_check
-    assert hours == 8
-
-    old = datetime.now() - timedelta(hours=13)
-    with open(plugin_updates.latest_check_path, "w", encoding="utf-8") as handle:
-        handle.write(str(int(old.timestamp())))
-
-    assert plugin_updates.should_check() == (True, 0)
-
-
-def test_should_check_without_a_previous_check(data_folder):
-    assert PluginUpdates().should_check() == (True, 0)
-
-
-@pytest.fixture
-def no_version_check(monkeypatch):
-    monkeypatch.setattr(MVTUpdates, "check", lambda self: "")
-    # Keep rich from wrapping the plugin lines while they are being asserted.
-    monkeypatch.setenv("COLUMNS", "200")
-
-
-@pytest.fixture
-def throttled_cache(monkeypatch, data_folder):
-    """Fill the findings cache and put the check inside its throttle window."""
-
-    def fill(findings, distributions):
-        PluginUpdates().set_findings(findings)
-        monkeypatch.setattr(
-            logo, "installed_plugin_distributions", lambda: distributions
-        )
-        monkeypatch.setattr(PluginUpdates, "should_check", lambda self: (False, 8))
-        monkeypatch.setattr(
-            PluginUpdates,
-            "check",
-            lambda self: pytest.fail("the check must be throttled"),
-        )
-
-    return fill
-
-
-def test_logo_prints_the_cached_plugin_updates(
-    capsys, no_version_check, throttled_cache
-):
-    throttled_cache(
-        [
-            {
-                "name": "example-plugin",
-                "installed": "1.0.0",
-                "latest": "1.2.0",
-                "origin": "pypi",
-                "upgrade_command": "pip install -U example-plugin",
-            }
-        ],
-        [FakeDistribution("example-plugin", version="1.0.0")],
-    )
-
-    logo.check_updates(disable_indicator_check=True)
-
-    output = capsys.readouterr().out
-    assert "Plugin updates available:" in output
-    assert "example-plugin  1.0.0 → 1.2.0   (pip install -U example-plugin)" in output
-
-
-def test_logo_does_not_print_a_cached_update_of_an_upgraded_plugin(
-    capsys, no_version_check, throttled_cache
-):
-    throttled_cache(
-        [
-            {
-                "name": "example-plugin",
-                "installed": "1.0.0",
-                "latest": "1.2.0",
-                "origin": "pypi",
-                "upgrade_command": "pip install -U example-plugin",
-            }
-        ],
-        # The analyst already upgraded the plugin the cached finding is about.
-        [FakeDistribution("example-plugin", version="1.2.0")],
-    )
-
-    logo.check_updates(disable_indicator_check=True)
-
-    assert "Plugin updates" not in capsys.readouterr().out
-
-
-def test_logo_prints_nothing_when_throttled_without_findings(
-    capsys, no_version_check, throttled_cache
-):
-    throttled_cache([], [FakeDistribution("example-plugin")])
-
-    logo.check_updates(disable_indicator_check=True)
-
-    assert "Plugin updates" not in capsys.readouterr().out
-
-
-def test_logo_survives_a_corrupt_plugin_cache(
-    monkeypatch, capsys, data_folder, no_version_check
-):
-    data_folder.mkdir(parents=True, exist_ok=True)
-    (data_folder / "plugin_updates.json").write_text(
-        json.dumps([{"oops": 1}]), encoding="utf-8"
-    )
-    monkeypatch.setattr(
-        logo,
-        "installed_plugin_distributions",
-        lambda: [FakeDistribution("example-plugin")],
-    )
-    monkeypatch.setattr(PluginUpdates, "should_check", lambda self: (False, 8))
-
-    logo.check_updates(disable_indicator_check=True)
-
-    assert "Plugin updates" not in capsys.readouterr().out
-
-
-def test_logo_skips_the_plugin_check_without_plugins(
-    monkeypatch, capsys, no_version_check
-):
-    monkeypatch.setattr(logo, "installed_plugin_distributions", list)
-    monkeypatch.setattr(
-        PluginUpdates,
-        "should_check",
-        lambda self: pytest.fail("plugins must not be checked without plugins"),
-    )
-
-    logo.check_updates(disable_indicator_check=True)
-
-    assert "Plugin updates" not in capsys.readouterr().out
-
-
-def test_logo_skips_the_plugin_check_without_network_access(
-    monkeypatch, capsys, no_version_check
-):
-    monkeypatch.setattr("mvt.common.logo.settings.NETWORK_ACCESS_ALLOWED", False)
-    monkeypatch.setattr(
-        logo,
-        "installed_plugin_distributions",
-        lambda: pytest.fail("plugins must not be listed without network access"),
-    )
-
-    logo.check_updates(disable_indicator_check=True)
-
-    assert "Plugin updates" not in capsys.readouterr().out
-
-
-def test_logo_skips_the_plugin_check_when_update_checks_are_disabled(
-    monkeypatch, capsys
-):
-    monkeypatch.setattr(
-        logo,
-        "installed_plugin_distributions",
-        lambda: pytest.fail("plugins must not be checked with --disable-update-check"),
-    )
-
-    logo.check_updates(disable_version_check=True, disable_indicator_check=True)
-
-    assert capsys.readouterr().out == ""

tests/common/test_utils.py

@@ -18,7 +18,6 @@ from mvt.common.utils import (
     generate_hashes_from_path,
     get_sha256_from_file_path,
     init_logging,
-    set_verbose_logging,
 )
 
 from ..utils import get_artifact_folder
@@ -123,29 +122,3 @@ class TestInitLogging:
             sum(isinstance(handler, MVTLogHandler) for handler in log.handlers)
             == handler_count
         )
-
-    def test_verbose_logging_finds_the_console_handler_among_others(self):
-        # Something else may have attached a handler to the "mvt" logger
-        # before MVT did, so the console handler is not always the first.
-        log = logging.getLogger("mvt")
-        init_logging()
-        foreign_handler = logging.NullHandler()
-        foreign_handler.setLevel(logging.CRITICAL)
-        log.handlers.insert(0, foreign_handler)
-
-        try:
-            set_verbose_logging(True)
-            console_handlers = [
-                handler
-                for handler in log.handlers
-                if isinstance(handler, MVTLogHandler)
-            ]
-            assert console_handlers
-            assert all(handler.level == logging.DEBUG for handler in console_handlers)
-            assert foreign_handler.level == logging.CRITICAL
-
-            set_verbose_logging(False)
-            assert all(handler.level == logging.INFO for handler in console_handlers)
-            assert foreign_handler.level == logging.CRITICAL
-        finally:
-            log.handlers.remove(foreign_handler)

tests/plugin_fixtures.py

@@ -73,7 +73,6 @@ def run_isolated_python(
     }
     isolated_environment["HOME"] = str(home)
     isolated_environment["XDG_CONFIG_HOME"] = str(home / "config")
-    isolated_environment["XDG_DATA_HOME"] = str(home / "data")
     if site_path is not None:
         isolated_environment["PYTHONPATH"] = str(site_path)
     isolated_environment.update(environment)

tests/test_check_android_androidqf.py

@@ -155,7 +155,7 @@ class TestCheckAndroidqfCommand:
             result = runner.invoke(check_androidqf, [str(path)])
 
         assert result.exit_code == 0
-        assert "Skipping backup modules: Invalid backup format" in caplog.text
+        assert "Skipping backup modules as backup.ab is malformed" in caplog.text
         assert not any(
             record.levelname in {"CRITICAL", "FATAL"} for record in caplog.records
         )

tests/test_cli.py

@@ -29,6 +29,7 @@ class TestMvtCommand:
         assert result.exit_code == 0
         assert "mvt-ios" in result.output
         assert "mvt-android" in result.output
+        assert "check-*" in result.output
 
     def test_version_prints_the_installed_version(self):
         result = CliRunner().invoke(cli, [*OFFLINE, "version"])

tests/test_cli_startup.py

@@ -1,28 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2026 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-
-import pytest
-
-from .plugin_fixtures import run_isolated_python
-
-# Importing a platform CLI must only build its command tree: the console
-# scripts import it before Click can answer a shell completion request, which
-# the completion scripts make on every keystroke. Every command imports what
-# it runs when it is invoked. Each of these costs tens of milliseconds to
-# import and is the sign that a command implementation is imported too early.
-HEAVY_MODULES = ("pydantic", "requests", "Crypto", "mvt.common.module")
-
-
-@pytest.mark.parametrize("cli_module", ("mvt.ios.cli", "mvt.android.cli"))
-def test_importing_a_cli_does_not_import_the_module_machinery(cli_module, tmp_path):
-    result = run_isolated_python(
-        "import sys\n"
-        f"import {cli_module}\n"
-        f"print(','.join(name for name in {HEAVY_MODULES!r} if name in sys.modules))\n",
-        home=tmp_path / "home",
-    )
-
-    assert result.returncode == 0, result.stderr
-    assert result.stdout.strip() == "", f"{cli_module} imported {result.stdout.strip()}"

tests/test_cli_verbose.py

@@ -1,107 +0,0 @@
-# Mobile Verification Toolkit (MVT)
-# Copyright (c) 2021-2026 The MVT Authors.
-# Use of this software is governed by the MVT License 1.1 that can be found at
-#   https://license.mvt.re/1.1/
-
-import logging
-
-import pytest
-from click.testing import CliRunner
-
-from mvt.android.cli import cli as android_cli
-from mvt.cli import cli as mvt_cli
-from mvt.common.log import MVTLogHandler
-from mvt.common.utils import set_verbose_logging
-from mvt.ios.cli import cli as ios_cli
-
-# Keep the banner of the group callback from checking for updates online.
-OFFLINE = ["--disable-update-check", "--disable-indicator-update-check"]
-
-PROGRAMS = {"mvt": mvt_cli, "mvt-ios": ios_cli, "mvt-android": android_cli}
-
-
-@pytest.fixture(autouse=True)
-def _reset_console_level():
-    """Leave the console handler at its default level after every test."""
-    yield
-    set_verbose_logging(False)
-
-
-def _console_level():
-    """Return the level of MVT's own console log handler."""
-    for handler in logging.getLogger("mvt").handlers:
-        if isinstance(handler, MVTLogHandler):
-            return handler.level
-    raise AssertionError("MVT has no console log handler")
-
-
-class TestVerboseOnTheCommands:
-    @pytest.mark.parametrize("program", sorted(PROGRAMS))
-    def test_verbose_before_the_command_name_turns_on_debug(self, program):
-        cli = PROGRAMS[program]
-
-        result = CliRunner().invoke(cli, [*OFFLINE, "--verbose", "version"])
-
-        assert result.exit_code == 0
-        assert _console_level() == logging.DEBUG
-
-    @pytest.mark.parametrize("program", sorted(PROGRAMS))
-    def test_a_run_without_verbose_goes_back_to_info(self, program):
-        cli = PROGRAMS[program]
-        CliRunner().invoke(cli, [*OFFLINE, "--verbose", "version"])
-
-        result = CliRunner().invoke(cli, [*OFFLINE, "version"])
-
-        assert result.exit_code == 0
-        assert _console_level() == logging.INFO
-
-    def test_mvt_verbose_without_a_command_prints_the_help(self):
-        result = CliRunner().invoke(mvt_cli, [*OFFLINE, "--verbose"])
-
-        assert result.exit_code == 0
-        assert "Usage:" in result.output
-        assert _console_level() == logging.DEBUG
-
-
-class TestVerboseOnTheCheckCommands:
-    def test_ios_command_default_does_not_undo_the_cli_choice(self, tmp_path):
-        result = CliRunner().invoke(
-            ios_cli,
-            [*OFFLINE, "--verbose", "check-backup", "--list-modules", str(tmp_path)],
-        )
-
-        assert result.exit_code == 0
-        assert _console_level() == logging.DEBUG
-
-    def test_ios_verbose_after_the_command_name_still_works(self, tmp_path):
-        result = CliRunner().invoke(
-            ios_cli,
-            [*OFFLINE, "check-backup", "--verbose", "--list-modules", str(tmp_path)],
-        )
-
-        assert result.exit_code == 0
-        assert _console_level() == logging.DEBUG
-
-    def test_android_command_default_does_not_undo_the_cli_choice(self, tmp_path):
-        result = CliRunner().invoke(
-            android_cli,
-            [*OFFLINE, "--verbose", "check-bugreport", "--list-modules", str(tmp_path)],
-        )
-
-        assert result.exit_code == 0
-        assert _console_level() == logging.DEBUG
-
-    def test_android_verbose_after_the_command_name_still_works(self, tmp_path):
-        result = CliRunner().invoke(
-            android_cli,
-            [*OFFLINE, "check-bugreport", "--verbose", "--list-modules", str(tmp_path)],
-        )
-
-        assert result.exit_code == 0
-        assert _console_level() == logging.DEBUG
-
-    def test_the_command_option_says_it_is_kept_for_compatibility(self):
-        result = CliRunner().invoke(ios_cli, [*OFFLINE, "check-backup", "--help"])
-
-        assert result.exit_code == 0
-        assert "kept for compatibility" in result.output