iotsploit-cli 0.0.6__tar.gz → 0.0.8__tar.gz

iotsploit_cli-0.0.8/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: iotsploit-cli
+Version: 0.0.8
+Summary: IoTSploit CLI shell (console + command modules) - IoT security testing interactive interface
+License: GPL-3.0-or-later
+Keywords: iot,security,testing,pentest,cli,shell
+Author: IoTSploit Team
+Author-email: support@iotsploit.org
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Hardware
+Requires-Dist: cmd2 (>=2.4,<3.0)
+Requires-Dist: iotsploit-core
+Requires-Dist: iotsploit-django
+Requires-Dist: iotsploit-drivers
+Requires-Dist: iotsploit-exploits
+Requires-Dist: iotsploit-mcp
+Requires-Dist: prompt-toolkit (>=3.0.48,<4.0.0)
+Project-URL: Documentation, https://www.iotsploit.org/
+Project-URL: Homepage, https://www.iotsploit.org/
+Project-URL: Repository, https://github.com/TKXB/iotsploit
+Description-Content-Type: text/markdown
+
+# iotsploit-cli
+
+IoTSploit interactive CLI shell for IoT security testing.
+
+## Overview
+
+This package provides the `iotsploit` command-line shell built on top of `cmd2`.
+It bundles the core console loop (`console.py`) and all command modules
+(`commands/`) that implement device management, plugin execution, target
+management, network operations, and more.
+
+## Installation
+
+```bash
+pip install iotsploit-cli
+```
+
+## Usage
+
+```bash
+iotsploit
+```
+
+Or with the Django server started immediately:
+
+```bash
+iotsploit --runserver
+```
+
+### Custom plugins
+
+`IOTSPLOIT_EXPLOIT_PLUGINS_DIR` can be used for user custom exploit plugins.
+`IOTSPLOIT_DEVICE_PLUGINS_DIR` can be used for user custom device plugins.
+
+## Command Palette
+
+The IoTSploit shell includes a live command palette for all commands.  When
+you type any character at the top-level interactive prompt, a menu appears
+immediately showing every eligible command matching that prefix with a short
+description beside each entry.
+
+### How it works
+
+1. Start typing any character at the empty prompt.
+2. The menu lists all visible commands matching the typed prefix (e.g. `e`
+   shows `edit`, `exploit`, `exit`, `execute_plugin`; `h` shows `help`,
+   `history`).
+3. Additional characters filter the list in real time (e.g. `ex` narrows to
+   `exit`, `execute_plugin`, `exploit`).
+4. Navigate the list, insert a selection, or dismiss the menu.
+
+### Keyboard controls
+
+| Key | Behavior |
+|-----|----------|
+| Any first-token character | Open the palette menu |
+| Additional characters | Filter the list case-insensitively |
+| Up / Down | Move selection without changing the buffer |
+| Tab | Insert the selected command name (does not submit) |
+| Enter | Accept the selected command and submit through cmd2 dispatch |
+| Escape | Close the menu and retain the current input text |
+| Backspace to empty | Close the menu |
+| Space after a command | Close the menu and allow argument entry |
+| Ctrl+C | Cancel the current input (normal shell behavior) |
+| Ctrl+D on empty line | Exit the shell (normal EOF behavior) |
+
+### Behaviour notes
+
+- The palette is **TTY-only**.  Non-interactive use (piped input, startup
+  scripts, non-TTY stdin) bypasses the palette entirely and uses the normal
+  cmd2 input path.
+- The command list is derived dynamically from the runtime command registry,
+  so newly loaded command modules appear without editing the palette.
+- Tab completion for arguments (after a space) still uses cmd2's existing
+  completion engine, including argument-specific completers and argparse
+  completers.
+- Selecting a command from the palette does **not** execute it; it inserts the
+  command name so you can type arguments before pressing Enter.
+
+## License
+
+GPL-3.0-or-later. See [LICENSE](../LICENSE) for details.
+For commercial use, contact wang3919379@gmail.com.
+

iotsploit_cli-0.0.8/README.md

@@ -0,0 +1,83 @@
+# iotsploit-cli
+
+IoTSploit interactive CLI shell for IoT security testing.
+
+## Overview
+
+This package provides the `iotsploit` command-line shell built on top of `cmd2`.
+It bundles the core console loop (`console.py`) and all command modules
+(`commands/`) that implement device management, plugin execution, target
+management, network operations, and more.
+
+## Installation
+
+```bash
+pip install iotsploit-cli
+```
+
+## Usage
+
+```bash
+iotsploit
+```
+
+Or with the Django server started immediately:
+
+```bash
+iotsploit --runserver
+```
+
+### Custom plugins
+
+`IOTSPLOIT_EXPLOIT_PLUGINS_DIR` can be used for user custom exploit plugins.
+`IOTSPLOIT_DEVICE_PLUGINS_DIR` can be used for user custom device plugins.
+
+## Command Palette
+
+The IoTSploit shell includes a live command palette for all commands.  When
+you type any character at the top-level interactive prompt, a menu appears
+immediately showing every eligible command matching that prefix with a short
+description beside each entry.
+
+### How it works
+
+1. Start typing any character at the empty prompt.
+2. The menu lists all visible commands matching the typed prefix (e.g. `e`
+   shows `edit`, `exploit`, `exit`, `execute_plugin`; `h` shows `help`,
+   `history`).
+3. Additional characters filter the list in real time (e.g. `ex` narrows to
+   `exit`, `execute_plugin`, `exploit`).
+4. Navigate the list, insert a selection, or dismiss the menu.
+
+### Keyboard controls
+
+| Key | Behavior |
+|-----|----------|
+| Any first-token character | Open the palette menu |
+| Additional characters | Filter the list case-insensitively |
+| Up / Down | Move selection without changing the buffer |
+| Tab | Insert the selected command name (does not submit) |
+| Enter | Accept the selected command and submit through cmd2 dispatch |
+| Escape | Close the menu and retain the current input text |
+| Backspace to empty | Close the menu |
+| Space after a command | Close the menu and allow argument entry |
+| Ctrl+C | Cancel the current input (normal shell behavior) |
+| Ctrl+D on empty line | Exit the shell (normal EOF behavior) |
+
+### Behaviour notes
+
+- The palette is **TTY-only**.  Non-interactive use (piped input, startup
+  scripts, non-TTY stdin) bypasses the palette entirely and uses the normal
+  cmd2 input path.
+- The command list is derived dynamically from the runtime command registry,
+  so newly loaded command modules appear without editing the palette.
+- Tab completion for arguments (after a space) still uses cmd2's existing
+  completion engine, including argument-specific completers and argparse
+  completers.
+- Selecting a command from the palette does **not** execute it; it inserts the
+  command name so you can type arguments before pressing Enter.
+
+## License
+
+GPL-3.0-or-later. See [LICENSE](../LICENSE) for details.
+For commercial use, contact wang3919379@gmail.com.

{iotsploit_cli-0.0.6 → iotsploit_cli-0.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "iotsploit-cli"
-version = "0.0.6"
+version = "0.0.8"
 description = "IoTSploit CLI shell (console + command modules) - IoT security testing interactive interface"
 authors = ["IoTSploit Team <support@iotsploit.org>"]
 readme = "README.md"
@@ -29,13 +29,13 @@ iotsploit = "iotsploit_cli.console:main"
 
 [tool.poetry.dependencies]
 python = ">=3.10,<4.0"
-iotsploit-core = "^0.0.6"
-iotsploit-django = "^0.0.6"
-iotsploit-drivers = "^0.0.6"
-iotsploit-exploits = "^0.0.6"
-iotsploit-mcp = "^0.0.6"
+iotsploit-core = "*"
+iotsploit-django = "*"
+iotsploit-drivers = "*"
+iotsploit-exploits = "*"
+iotsploit-mcp = "*"
 cmd2 = "^2.4"
-pwntools = "^4.12"
+prompt-toolkit = "^3.0.48"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.4.0"

iotsploit_cli-0.0.8/src/iotsploit_cli/command_palette.py

@@ -0,0 +1,349 @@
+"""Command palette for IoTSploit CLI -- live command discovery.
+
+This module implements the live prompt-toolkit command palette that shows
+eligible commands as the user types at the top-level interactive prompt.
+Any typed prefix triggers the palette; additional characters filter the list
+in real time.  It preserves all existing cmd2 behaviour for non-TTY input,
+nested prompts, scripts, and argument completion.
+
+The public classes are:
+
+* :class:`CommandPaletteEntry`       -- immutable metadata value
+* :class:`CommandCatalog`            -- UI-independent metadata provider
+* :class:`Cmd2CompletionAdapter`     -- bridges cmd2 readline Tab completion
+* :class:`CommandPaletteCompleter`   -- prompt-toolkit ``Completer``
+* :class:`PaletteInputSession`       -- prompt-toolkit ``PromptSession`` wrapper
+
+This module must **not** import anything from ``iotsploit_cli.console`` or
+Django so it can be unit-tested in isolation.
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Any, Iterable, List, Optional
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import (
+    Completion,
+    CompleteEvent,
+    Completer,
+)
+from prompt_toolkit.shortcuts import CompleteStyle
+from prompt_toolkit.document import Document
+from prompt_toolkit.formatted_text import ANSI
+from prompt_toolkit.history import InMemoryHistory
+
+# --------------------------------------------------------------------------- #
+#  Constants
+# --------------------------------------------------------------------------- #
+
+FALLBACK_DESCRIPTION = "No description available"
+EOF_SENTINEL = "eof"
+
+# Matches ANSI/CSI escape sequences so descriptions are control-char free.
+_ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]")
+
+
+# --------------------------------------------------------------------------- #
+#  Helpers
+# --------------------------------------------------------------------------- #
+
+
+def _sanitize_description(raw: Optional[str]) -> str:
+    """Strip ANSI control characters and normalise whitespace."""
+    if not raw:
+        return FALLBACK_DESCRIPTION
+    cleaned = _ANSI_ESCAPE_RE.sub("", raw)
+    cleaned = " ".join(cleaned.split())
+    if not cleaned:
+        return FALLBACK_DESCRIPTION
+    return cleaned
+
+
+# --------------------------------------------------------------------------- #
+#  CommandPaletteEntry
+# --------------------------------------------------------------------------- #
+
+
+@dataclass(frozen=True)
+class CommandPaletteEntry:
+    """Immutable value describing a single palette entry."""
+
+    name: str
+    description: str
+    category: Optional[str] = None
+
+
+# --------------------------------------------------------------------------- #
+#  CommandCatalog  (UI-independent metadata provider)
+# --------------------------------------------------------------------------- #
+
+
+class CommandCatalog:
+    """UI-independent command metadata provider for the command palette.
+
+    The catalog reads metadata **only** -- it never calls a ``do_*`` handler.
+    """
+
+    def __init__(self, shell: Any) -> None:
+        """Store a reference to the shell; do not invoke handlers."""
+        self._shell = shell
+
+    # -- public API -------------------------------------------------------- #
+
+    def get_eligible_entries(self, prefix: str) -> List[CommandPaletteEntry]:
+        """Return eligible palette entries whose name starts with *prefix*.
+
+        Matching is case-insensitive.  Results are sorted with exact matches
+        first, then alphabetical.
+        """
+        if not prefix:
+            return []
+        prefix_lower = prefix.lower()
+        entries: List[CommandPaletteEntry] = []
+
+        try:
+            visible = self._shell.get_visible_commands()
+        except Exception:
+            return []
+
+        # Build exclusion sets for aliases, macros, and the eof sentinel.
+        aliases: set = set()
+        macros: set = set()
+        if hasattr(self._shell, "aliases") and self._shell.aliases:
+            aliases = set(self._shell.aliases.keys())
+        if hasattr(self._shell, "macros") and self._shell.macros:
+            macros = set(self._shell.macros.keys())
+
+        for cmd_name in visible:
+            # Prefix filter (case-insensitive)
+            if not cmd_name.lower().startswith(prefix_lower):
+                continue
+            # Exclude eof sentinel
+            if cmd_name == EOF_SENTINEL:
+                continue
+            # Exclude aliases and macros (MVP: no stable description metadata)
+            if cmd_name in aliases or cmd_name in macros:
+                continue
+
+            # Description via the shell's existing doc extractor
+            try:
+                raw_doc = self._shell.get_command_doc(cmd_name)
+            except Exception:
+                raw_doc = None
+            description = _sanitize_description(raw_doc)
+
+            # Optional category from cmd2's @with_category decorator
+            category: Optional[str] = None
+            cmd_func = getattr(self._shell, "do_" + cmd_name, None)
+            if cmd_func is not None and hasattr(cmd_func, "category"):
+                category = cmd_func.category
+
+            entries.append(
+                CommandPaletteEntry(
+                    name=cmd_name,
+                    description=description,
+                    category=category,
+                )
+            )
+
+        # Sort: exact match first, then alphabetical by name
+        entries.sort(
+            key=lambda e: (e.name.lower() != prefix_lower, e.name.lower())
+        )
+        return entries
+
+    @staticmethod
+    def is_first_token_context(text: str, cursor_pos: int) -> bool:
+        """Return ``True`` if the cursor is in the first token and it is non-empty.
+
+        Leading whitespace is skipped so that ``  he`` is recognised the same
+        as ``he``.  This activates the palette for any command prefix, not just
+        a specific letter.
+        """
+        stripped = text.lstrip()
+        if not stripped:
+            return False
+        offset = len(text) - len(stripped)
+        first_space = stripped.find(" ")
+        if first_space == -1:
+            in_first_token = True
+            first_word = stripped
+        else:
+            rel_cursor = cursor_pos - offset
+            in_first_token = rel_cursor <= first_space
+            first_word = stripped[:first_space]
+
+        if not in_first_token:
+            return False
+        if not first_word:
+            return False
+        return True
+
+
+# --------------------------------------------------------------------------- #
+#  Cmd2CompletionAdapter  (bridges cmd2 readline Tab completion)
+# --------------------------------------------------------------------------- #
+
+
+class Cmd2CompletionAdapter:
+    """Bridge cmd2's readline-based ``complete()`` to prompt-toolkit.
+
+    When the user presses **Tab** outside the first-token context (i.e.
+    for argument completion), this adapter temporarily mocks the ``readline``
+    module functions that cmd2 reads and calls ``shell.complete(text, 0)`` to
+    populate ``completion_matches`` / ``display_matches``.
+    """
+
+    def __init__(self, shell: Any) -> None:
+        self._shell = shell
+
+    def get_completions(self, document: Document) -> Iterable[Completion]:
+        """Delegate to cmd2's ``complete()`` and yield prompt-toolkit Completions."""
+        try:
+            from cmd2 import rl_utils
+
+            readline_mod = rl_utils.readline
+        except (ImportError, AttributeError):
+            return
+
+        line = document.text
+        cursor = document.cursor_position
+
+        # Find the current word being completed (scan backwards for whitespace)
+        word_start = cursor
+        while word_start > 0 and not line[word_start - 1].isspace():
+            word_start -= 1
+        text = line[word_start:cursor]
+
+        if not text:
+            return
+
+        # Save originals
+        orig_get_line_buffer = readline_mod.get_line_buffer
+        orig_get_begidx = readline_mod.get_begidx
+        orig_get_endidx = readline_mod.get_endidx
+
+        try:
+            # Mock readline functions so cmd2's complete() sees the PT Document
+            readline_mod.get_line_buffer = lambda: line
+            readline_mod.get_begidx = lambda: word_start
+            readline_mod.get_endidx = lambda: cursor
+
+            # state=0 triggers _reset_completion_defaults + _perform_completion
+            self._shell.complete(text, 0)
+
+            matches = getattr(self._shell, "completion_matches", [])
+            displays = getattr(self._shell, "display_matches", matches)
+
+            for i, match in enumerate(matches):
+                display = displays[i] if i < len(displays) else match
+                yield Completion(
+                    match,
+                    start_position=-len(text),
+                    display=display,
+                )
+        except Exception:
+            return
+        finally:
+            # Always restore originals
+            readline_mod.get_line_buffer = orig_get_line_buffer
+            readline_mod.get_begidx = orig_get_begidx
+            readline_mod.get_endidx = orig_get_endidx
+
+
+# --------------------------------------------------------------------------- #
+#  CommandPaletteCompleter  (prompt-toolkit Completer)
+# --------------------------------------------------------------------------- #
+
+
+class CommandPaletteCompleter(Completer):
+    """prompt-toolkit ``Completer`` for live command palette and cmd2 Tab delegation.
+
+    * While the cursor is in the first token and it is non-empty, yield live
+      palette entries for any command prefix (works with
+      ``complete_while_typing=True``).
+    * When **Tab** is explicitly requested outside the first token (i.e.
+      for argument completion), delegate to :class:`Cmd2CompletionAdapter`
+      so existing cmd2 argument completion still works.
+    """
+
+    def __init__(
+        self,
+        shell: Any,
+        catalog: CommandCatalog,
+        cmd2_adapter: Cmd2CompletionAdapter,
+    ) -> None:
+        self._shell = shell
+        self._catalog = catalog
+        self._adapter = cmd2_adapter
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        text = document.text_before_cursor
+        cursor = document.cursor_position
+
+        # Strip leading whitespace for token analysis
+        stripped = text.lstrip()
+        offset = len(text) - len(stripped)
+        first_space = stripped.find(" ")
+        if first_space == -1:
+            in_first_token = True
+            first_word = stripped
+        else:
+            rel_cursor = cursor - offset
+            in_first_token = rel_cursor <= first_space
+            first_word = stripped[:first_space]
+
+        # -- live palette for any first-token prefix ---------------------- #
+        if in_first_token and first_word:
+            for entry in self._catalog.get_eligible_entries(first_word):
+                yield Completion(
+                    entry.name,
+                    start_position=-len(first_word),
+                    display=entry.name,
+                    display_meta=entry.description,
+                )
+        # -- explicit Tab delegation (argument completion) ---------------- #
+        elif complete_event.completion_requested:
+            yield from self._adapter.get_completions(document)
+
+
+# --------------------------------------------------------------------------- #
+#  PaletteInputSession  (prompt-toolkit PromptSession wrapper)
+# --------------------------------------------------------------------------- #
+
+
+class PaletteInputSession:
+    """Wrap a prompt-toolkit ``PromptSession`` for the command palette.
+
+    Most key behaviour (Up/Down navigation, Tab apply, Enter accept, Escape
+    dismiss) is provided by prompt-toolkit's defaults when
+    ``complete_while_typing=True`` with ``CompleteStyle.COLUMN``.
+    """
+
+    def __init__(self, shell: Any, completer: CommandPaletteCompleter) -> None:
+        self._shell = shell
+        self._session: PromptSession = PromptSession(
+            completer=completer,
+            complete_while_typing=True,
+            complete_style=CompleteStyle.COLUMN,
+            history=InMemoryHistory(),
+        )
+
+    def prompt(self, prompt_text: str) -> str:
+        """Display the prompt and return the accepted line.
+
+        Raises:
+            KeyboardInterrupt: when the user presses Ctrl+C.
+            Returns ``'eof'`` on EOF (Ctrl+D on empty line), matching cmd2.
+        """
+        message = ANSI(prompt_text) if prompt_text else ""
+        try:
+            line = self._session.prompt(message=message)
+            return line
+        except KeyboardInterrupt:
+            raise
+        except EOFError:
+            return EOF_SENTINEL

{iotsploit_cli-0.0.6 → iotsploit_cli-0.0.8}/src/iotsploit_cli/commands/device_commands.py

@@ -233,7 +233,7 @@ class DeviceCommands(BaseCommands):
             
             # 执行设备扫描
             logger.info(ansi.style("Scanning for devices...", fg=ansi.Fg.CYAN))
-            discovered_devices = device_registry.scan_devices()
+            device_registry.scan_devices()
             
             # 获取所有设备（包括已存储的和新发现的）
             all_devices = device_registry.device_store.devices
@@ -533,4 +533,4 @@ class DeviceCommands(BaseCommands):
             logger.debug("Detailed error:", exc_info=True)
 
     # Add alias for device_import
-    do_dimport = do_device_import
+    do_dimport = do_device_import

{iotsploit_cli-0.0.6 → iotsploit_cli-0.0.8}/src/iotsploit_cli/commands/django_commands.py

@@ -24,6 +24,38 @@ logger = iots_logger.get_logger(__name__)
 class DjangoCommands(BaseCommands):
     """Django-related commands for the SAT Shell"""
 
+    def _services_log_to_console(self) -> bool:
+        override = os.getenv("IOTSPLOIT_SERVICE_LOG_TO_CONSOLE", "").strip().lower()
+        if override:
+            return override in ("1", "true", "yes", "y", "on")
+        return os.getenv("IOTSPLOIT_LOG_FORMAT", "standard").strip().lower() == "standard"
+
+    def _open_service_log(self, service_name: str):
+        if not hasattr(self, "_service_log_files"):
+            self._service_log_files = []
+
+        log_dir = os.getenv("IOTSPLOIT_SERVICE_LOG_DIR", "/tmp/sat_logs")
+        os.makedirs(log_dir, exist_ok=True)
+        log_path = os.path.join(log_dir, f"{service_name}.log")
+        log_file = open(log_path, "a", buffering=1, encoding="utf-8")
+        self._service_log_files.append(log_file)
+        return log_file, log_path
+
+    def _service_stdio(self, service_name: str):
+        if self._services_log_to_console():
+            return sys.stdout, sys.stderr, None
+
+        log_file, log_path = self._open_service_log(service_name)
+        return log_file, subprocess.STDOUT, log_path
+
+    def _close_service_log_files(self):
+        for log_file in getattr(self, "_service_log_files", []):
+            try:
+                log_file.close()
+            except Exception:
+                pass
+        self._service_log_files = []
+
     def _check_redis_available(self) -> Tuple[bool, str]:
         """
         Preflight check for Redis reachability using Django settings.
@@ -66,13 +98,13 @@ class DjangoCommands(BaseCommands):
 
     @cmd2.with_category('Django Commands')
     def do_runserver(self, arg):
-        'Start Django development server, Daphne WebSocket server, MCP WebSocket bridge, and Celery worker in the background'
+        'Start Django development server, Daphne WebSocket server, MCP HTTP server, and Celery worker in the background'
         if self.django_server_process or self.daphne_server_process:
             self.poutput("Servers are already running.")
             return
 
         try:
-            logger.info("Attempting to start Django, Daphne, MCP WebSocket bridge, and Celery servers in background...")
+            logger.info("Attempting to start Django, Daphne, MCP HTTP server, and Celery servers in background...")
             
             # Preflight: check Redis and fail fast if unavailable
             redis_ok, redis_msg = self._check_redis_available()
@@ -97,11 +129,11 @@ class DjangoCommands(BaseCommands):
                 sys.executable,
                 '-m',
                 'iotsploit_mcp.cli',
-                'ws',
+                'http',
                 '--host',
-                '0.0.0.0',
+                '127.0.0.1',
                 '--port',
-                '9998',
+                '9900',
             ]
             celery_cmd = [
                 sys.executable,
@@ -112,54 +144,64 @@ class DjangoCommands(BaseCommands):
                 'worker',
                 '--loglevel=info'
             ]
+            service_env = os.environ.copy()
             
             logger.info(f"Running Django command: {' '.join(django_cmd)}")
             logger.info(f"Running Daphne command: {' '.join(daphne_cmd)}")
-            logger.info(f"Running MCP WebSocket Bridge command: {' '.join(mcp_bridge_cmd)}")
+            logger.info(f"Running MCP HTTP server command: {' '.join(mcp_bridge_cmd)}")
             logger.info(f"Running Celery command: {' '.join(celery_cmd)}")
+            if not self._services_log_to_console():
+                logger.info(f"Service logs are redirected to {os.getenv('IOTSPLOIT_SERVICE_LOG_DIR', '/tmp/sat_logs')}")
             
             # Start the processes with direct output to stdout/stderr
+            django_stdout, django_stderr, _ = self._service_stdio("django")
             self.django_server_process = subprocess.Popen(
                 django_cmd, 
-                stdout=sys.stdout,  # 直接输出到控制台
-                stderr=sys.stderr,
-                universal_newlines=True
+                stdout=django_stdout,
+                stderr=django_stderr,
+                universal_newlines=True,
+                env=service_env,
             )
             
+            daphne_stdout, daphne_stderr, _ = self._service_stdio("daphne")
             self.daphne_server_process = subprocess.Popen(
                 daphne_cmd, 
-                stdout=sys.stdout,  # 直接输出到控制台
-                stderr=sys.stderr,
-                universal_newlines=True
+                stdout=daphne_stdout,
+                stderr=daphne_stderr,
+                universal_newlines=True,
+                env=service_env,
             )
             
-            # Start the WebSocket bridge in its own process group so that we can
-            # later terminate the entire group (bridge + sat_fastmcp child)
+            # Start the MCP HTTP server in its own process group so that we can
+            # later terminate the entire group
             # Set up environment variables for MCP bridge (Django API URL)
-            mcp_env = os.environ.copy()
+            mcp_env = service_env.copy()
             mcp_env.setdefault('IOTSPLOIT_DJANGO_API_BASE_URL', 'http://127.0.0.1:8888')
             
+            mcp_stdout, mcp_stderr, _ = self._service_stdio("mcp")
             self.mcp_bridge_process = subprocess.Popen(
                 mcp_bridge_cmd,
-                stdout=sys.stdout,  # 直接输出到控制台
-                stderr=sys.stderr,
+                stdout=mcp_stdout,
+                stderr=mcp_stderr,
                 universal_newlines=True,
                 start_new_session=True,  # create new session = new PGID on POSIX
                 env=mcp_env
             )
             
+            celery_stdout, celery_stderr, _ = self._service_stdio("celery")
             self.celery_worker_process = subprocess.Popen(
                 celery_cmd,
-                stdout=sys.stdout,  # 直接输出到控制台
-                stderr=sys.stderr,
-                universal_newlines=True
+                stdout=celery_stdout,
+                stderr=celery_stderr,
+                universal_newlines=True,
+                env=service_env,
             )
             
             logger.info("All servers started successfully in the background.")
             logger.info("Services running on:")
             logger.info("  - Django HTTP API: http://localhost:8888")
             logger.info("  - Daphne WebSocket: ws://localhost:9999")
-            logger.info("  - MCP WebSocket Bridge: ws://localhost:9998")
+            logger.info("  - MCP HTTP (Streamable HTTP): http://127.0.0.1:9900/mcp")
             logger.info("  - Celery Worker: background task processing")
             
             # Wait for HTTP server to be available and initialize devices
@@ -197,7 +239,7 @@ class DjangoCommands(BaseCommands):
 
     @cmd2.with_category('Django Commands')
     def do_stop_server(self, arg):
-        'Stop Django development server, Daphne WebSocket server, MCP WebSocket bridge, and Celery worker'
+        'Stop Django development server, Daphne WebSocket server, MCP HTTP server, and Celery worker'
         try:
             # Cleanup devices using HTTP endpoint (GET method)
             # Only attempt HTTP cleanup if the Django server process is still alive
@@ -241,6 +283,8 @@ class DjangoCommands(BaseCommands):
             if self.celery_worker_process:
                 self.celery_worker_process.terminate()
                 self.celery_worker_process = None
+
+            self._close_service_log_files()
             
             if not any([self.django_server_process, self.daphne_server_process, 
                         getattr(self, 'mcp_bridge_process', None),

{iotsploit_cli-0.0.6 → iotsploit_cli-0.0.8}/src/iotsploit_cli/commands/firmware_commands.py

@@ -3,7 +3,6 @@
 import cmd2
 from cmd2 import ansi
 from .base_commands import BaseCommands
-from iotsploit_django.tools.input_mgr import Input_Mgr
 from iotsploit_core.core.tool_service import get_firmware_service
 from iotsploit_core.utils import iots_logger
 

{iotsploit_cli-0.0.6 → iotsploit_cli-0.0.8}/src/iotsploit_cli/commands/linux_commands.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 
 import cmd2
-from cmd2 import ansi
 import subprocess
 from .base_commands import BaseCommands
 from iotsploit_core.utils import iots_logger

{iotsploit_cli-0.0.6 → iotsploit_cli-0.0.8}/src/iotsploit_cli/commands/network_commands.py

@@ -4,7 +4,7 @@ import cmd2
 from cmd2 import ansi
 import time
 from .base_commands import BaseCommands
-from iotsploit_django.tools.wifi_mgr import WiFi_Mgr
+from iotsploit_platforms import get_shared_wifi_backend
 from iotsploit_django.tools.input_mgr import Input_Mgr
 from iotsploit_core.utils import iots_logger
 
@@ -27,10 +27,14 @@ class NetworkCommands(BaseCommands):
         
         # Attempt to connect
         logger.info(ansi.style(f"Attempting to connect to {ssid}...", fg=ansi.Fg.CYAN))
-        WiFi_Mgr.Instance().sta_connect_wifi(ssid, password)
-        
+        wifi_backend = get_shared_wifi_backend()
+        try:
+            wifi_backend.sta_connect(str(ssid), str(password))
+        except Exception as e:
+            logger.error(ansi.style(f"WiFi connection failed: {e}", fg=ansi.Fg.RED))
+
         # Wait for connection to establish
         time.sleep(2)
-        
+
         # Show connection status
-        WiFi_Mgr.Instance().status()
+        wifi_backend.status()

{iotsploit_cli-0.0.6 → iotsploit_cli-0.0.8}/src/iotsploit_cli/commands/plugin_commands.py

@@ -5,8 +5,6 @@ from cmd2 import ansi
 from .base_commands import BaseCommands
 from iotsploit_core.core.exploit_spec import ExploitResult
 from iotsploit_django.tools.input_mgr import Input_Mgr
-from iotsploit_django.adapters.django.plugins.models import Plugin
-from iotsploit_django.adapters.django.plugins.models import PluginGroup, PluginGroupTree
 from iotsploit_core.utils import iots_logger
 
 logger = iots_logger.get_logger(__name__)
@@ -66,58 +64,80 @@ class PluginCommands(BaseCommands):
             target_manager = self.target_manager
             current_target = target_manager.get_current_target()
             
-            # Prepare target dictionary
+            # Prepare target dictionary (device/target info only, e.g. ip_address)
             target_dict = {}
-            
-            # If we have a target, include its properties
             if current_target:
-                # Add target properties to target dictionary
                 target_dict = current_target.get_info() if hasattr(current_target, 'get_info') else {}
-            
-            # Prompt for required parameters that are not in the target
+
+            # Collect the plugin's declared parameters separately from the target.
+            # Plugins read their params from `parameters` (not `target`), so these
+            # must be passed as parameters=, matching the HTTP/GUI execute path.
+            # We prompt for every declared parameter (not only required ones) so the
+            # TUI mirrors the GUI. Each prompt is labeled REQUIRED or optional:
+            #   - required  -> the user must enter a non-empty value.
+            #   - optional  -> the declared default is shown; pressing Enter skips it.
+            parameters = {}
             for param_name, param_info in plugin_params.items():
-                if param_name not in target_dict and param_info.get('required', False):
-                    param_type = param_info.get('type', 'str')
-                    description = param_info.get('description', f"Enter {param_name}")
-                    default = param_info.get('default')
-                    validation = param_info.get('validation', {})
-                    
-                    if param_type == 'str':
-                        if 'choices' in validation:
-                            # Use single_choice for string with choices
-                            value = Input_Mgr.Instance().single_choice(
-                                f"{description} (Choose one)",
-                                validation['choices']
-                            )
+                # Skip params already satisfied by the current target
+                if param_name in target_dict:
+                    continue
+
+                param_type = param_info.get('type', 'str')
+                required = param_info.get('required', False)
+                description = param_info.get('description', f"Enter {param_name}")
+                default = param_info.get('default')
+                validation = param_info.get('validation', {})
+
+                # Label so the user knows whether the field is mandatory or skippable
+                if required:
+                    prompt = f"{description} (REQUIRED)"
+                elif default is not None:
+                    prompt = f"{description} (optional, default: {default}, press Enter to skip)"
+                else:
+                    prompt = f"{description} (optional, press Enter to skip)"
+
+                if param_type == 'int':
+                    min_val = validation.get('min')
+                    max_val = validation.get('max')
+                    value = Input_Mgr.Instance().int_input(
+                        prompt,
+                        default=default if isinstance(default, int) else None,
+                        min_val=min_val,
+                        max_val=max_val
+                    )
+                elif param_type == 'bool':
+                    value = Input_Mgr.Instance().yes_no_input(
+                        prompt,
+                        default=bool(default) if default is not None else True
+                    )
+                elif param_type == 'str' and 'choices' in validation:
+                    value = Input_Mgr.Instance().single_choice(
+                        f"{prompt} (Choose one)",
+                        validation['choices']
+                    )
+                elif required:
+                    # Mandatory free-text: re-prompt until the user enters something
+                    value = Input_Mgr.Instance().string_input(
+                        prompt,
+                        verify_func=lambda s: bool(s and s.strip())
+                    )
+                else:
+                    # Optional free-text: empty input skips the field. Fall back to the
+                    # declared default if there is one, otherwise omit it entirely so
+                    # the plugin applies its own default.
+                    value = Input_Mgr.Instance().string_input(prompt)
+                    if value is None or value == "":
+                        if default is not None:
+                            value = default
                         else:
-                            # Regular string input
-                            value = Input_Mgr.Instance().string_input(description)
-                    elif param_type == 'int':
-                        # Integer input with optional min/max validation
-                        min_val = validation.get('min')
-                        max_val = validation.get('max')
-                        value = Input_Mgr.Instance().int_input(
-                            description,
-                            min_val=min_val,
-                            max_val=max_val
-                        )
-                    elif param_type == 'bool':
-                        # Boolean input
-                        value = Input_Mgr.Instance().yes_no_input(
-                            description,
-                            default=default if default is not None else True
-                        )
-                    else:
-                        # Default to string for unknown types
-                        value = Input_Mgr.Instance().string_input(description)
-                    
-                    # Add to target dict
-                    target_dict[param_name] = value
-            
-            logger.debug(f"Executing plugin with target configuration: {target_dict}")
-            
-            # Now execute the plugin with our target dictionary
-            result = self.plugin_manager.execute_plugin(choice, target=target_dict)
+                            continue
+
+                parameters[param_name] = value
+
+            logger.debug(f"Executing plugin '{choice}' with target={target_dict}, parameters={parameters}")
+
+            # Execute with target (device info) and parameters (plugin inputs) kept separate
+            result = self.plugin_manager.execute_plugin(choice, target=target_dict, parameters=parameters)
             
             # Check if this is an async execution
             if isinstance(result, dict) and result.get('execution_type') == 'async':

{iotsploit_cli-0.0.6 → iotsploit_cli-0.0.8}/src/iotsploit_cli/commands/system_commands.py

@@ -2,9 +2,11 @@
 
 import cmd2
 from cmd2 import ansi
+import os
 from .base_commands import BaseCommands
 from iotsploit_core.core.exploit_spec import ExploitResult
 from iotsploit_django.tools.input_mgr import Input_Mgr
+from iotsploit_django.tools.xlogger import xlog
 from iotsploit_core.utils import iots_logger
 
 logger = iots_logger.get_logger(__name__)
@@ -74,4 +76,46 @@ class SystemCommands(BaseCommands):
             logger.debug("Detailed error:", exc_info=True)
 
     # Add an alias for set_log_level
-    do_sll = do_set_log_level 
+    do_sll = do_set_log_level
+
+    @cmd2.with_category('System Commands')
+    def do_set_log_format(self, arg):
+        'Set the terminal logging format (standard, compact, plain)'
+        valid_formats = ['standard', 'compact', 'plain']
+
+        if not arg:
+            selected_format = Input_Mgr.Instance().single_choice(
+                "Select terminal log format",
+                valid_formats
+            )
+        else:
+            selected_format = arg.strip().lower()
+            if selected_format not in valid_formats:
+                logger.error(ansi.style(f"Invalid log format. Choose from: {', '.join(valid_formats)}", fg=ansi.Fg.RED))
+                return
+
+        try:
+            os.environ["IOTSPLOIT_LOG_FORMAT"] = selected_format
+            iots_logger.set_format(selected_format)
+            xlog.set_format(selected_format)
+            logger.info(ansi.style(f"Log format set to {selected_format}", fg=ansi.Fg.GREEN))
+            running_services = any(
+                getattr(self, attr, None)
+                for attr in (
+                    "django_server_process",
+                    "daphne_server_process",
+                    "mcp_bridge_process",
+                    "celery_worker_process",
+                )
+            )
+            if running_services and selected_format != "standard":
+                logger.warning(
+                    "Already-running service processes keep their current terminal output. "
+                    "Run stop_server then runserver to redirect service logs to /tmp/sat_logs."
+                )
+        except Exception as e:
+            logger.error(ansi.style(f"Error setting log format: {str(e)}", fg=ansi.Fg.RED))
+            logger.debug("Detailed error:", exc_info=True)
+
+    # Add an alias for set_log_format
+    do_slf = do_set_log_format

{iotsploit_cli-0.0.6 → iotsploit_cli-0.0.8}/src/iotsploit_cli/commands/target_commands.py

@@ -159,7 +159,6 @@ class TargetCommands(BaseCommands):
             
             else:
                 # Handle regular field editing
-                current_value = target.get(field, '')
                 new_value = Input_Mgr.Instance().string_input(
                     f"Enter new value for {field}"
                 )

{iotsploit_cli-0.0.6 → iotsploit_cli-0.0.8}/src/iotsploit_cli/console.py

@@ -7,6 +7,29 @@ import inspect
 from typing import Dict
 import argparse
 
+LOG_FORMAT_CHOICES = ("standard", "compact", "plain")
+
+
+def _prime_log_format_env_from_argv(argv):
+    selected_format = None
+    idx = 0
+    while idx < len(argv):
+        arg = argv[idx]
+        if arg == '--plain-log' and selected_format is None:
+            selected_format = "plain"
+        elif arg == '--log-format' and idx + 1 < len(argv):
+            selected_format = argv[idx + 1].strip().lower()
+            idx += 1
+        elif arg.startswith('--log-format='):
+            selected_format = arg.split('=', 1)[1].strip().lower()
+        idx += 1
+
+    if selected_format in LOG_FORMAT_CHOICES:
+        os.environ["IOTSPLOIT_LOG_FORMAT"] = selected_format
+
+
+_prime_log_format_env_from_argv(sys.argv[1:])
+
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "iotsploit_django.settings.dev")
 
 import django
@@ -66,6 +89,20 @@ ensure_database_initialized()
 # Now it's safe to import Django and other modules
 import cmd2
 from cmd2 import ansi
+
+# Command palette imports (prompt-toolkit based live command discovery).
+# Wrapped in try/except so the shell still works if prompt-toolkit is missing.
+try:
+    from iotsploit_cli.command_palette import (
+        CommandCatalog,
+        Cmd2CompletionAdapter,
+        CommandPaletteCompleter,
+        PaletteInputSession,
+    )
+    _PALETTE_AVAILABLE = True
+except ImportError:  # pragma: no cover
+    _PALETTE_AVAILABLE = False
+
 from iotsploit_django.adapters.django.target_models import TargetManager
 from iotsploit_core.domain.target import Vehicle
 from iotsploit_django.composition_root.wiring import get_device_driver_manager, get_exploit_plugin_manager
@@ -75,8 +112,7 @@ from iotsploit_django.tools.env_mgr import Env_Mgr
 from iotsploit_django.tools.report_mgr import Report_Mgr
 from iotsploit_django.tools.input_mgr import Input_Mgr
 from iotsploit_django.tools.xlogger import xlog as logger
-from pwnlib import term
-term.term_mode = True
+from iotsploit_core.utils import iots_logger
 
 def global_exception_handler(exctype, value, traceback):
     logger.error("Unhandled exception", exc_info=(exctype, value, traceback))
@@ -227,12 +263,83 @@ class SAT_Shell(SAT_Shell_Base):
             'run_script': 'Shell Commands',
             'runserver': 'Shell Commands',
             'set': 'Shell Commands',
+            'set_log_format': 'Shell Commands',
             'set_log_level': 'Shell Commands',
             'shell': 'Shell Commands',
             'shortcuts': 'Shell Commands',
+            'slf': 'Shell Commands',
+            'sll': 'Shell Commands',
             'stop_server': 'Shell Commands',
         })
 
+        # -- Command palette initialization (TTY-only) --------------------- #
+        # The palette uses prompt-toolkit for live command discovery.
+        # It is only initialized when stdin/stdout are TTYs so that non-interactive
+        # use (pipes, scripts, tests) bypasses it entirely.
+        self._palette_session = None
+        if (
+            _PALETTE_AVAILABLE
+            and sys.stdin.isatty()
+            and sys.stdout.isatty()
+        ):
+            try:
+                catalog = CommandCatalog(self)
+                adapter = Cmd2CompletionAdapter(self)
+                completer = CommandPaletteCompleter(self, catalog, adapter)
+                self._palette_session = PaletteInputSession(self, completer)
+            except Exception:
+                self._palette_session = None
+
+    def read_input(
+        self,
+        prompt: str,
+        *,
+        history=None,
+        completion_mode=cmd2.utils.CompletionMode.NONE,
+        preserve_quotes=False,
+        choices=None,
+        choices_provider=None,
+        completer=None,
+        parser=None,
+    ) -> str:
+        """Override cmd2's ``read_input`` to use the palette for top-level prompts.
+
+        Only intercepts when:
+        * ``completion_mode`` is ``COMMANDS`` (the top-level interactive prompt)
+        * stdin and stdout are TTYs
+        * ``use_rawinput`` is True
+        * the palette session was successfully initialized
+        * we are not at a continuation prompt
+
+        Everything else delegates to ``super().read_input()`` unchanged.
+        """
+        if (
+            completion_mode == cmd2.utils.CompletionMode.COMMANDS
+            and self._palette_session is not None
+            and not getattr(self, "_at_continuation_prompt", False)
+            and sys.stdin.isatty()
+            and sys.stdout.isatty()
+            and self.use_rawinput
+        ):
+            try:
+                return self._palette_session.prompt(prompt)
+            except (KeyboardInterrupt, EOFError):
+                raise
+            except Exception:
+                # Safe fallback: use cmd2's default input on any unexpected error
+                pass
+
+        return super().read_input(
+            prompt,
+            history=history,
+            completion_mode=completion_mode,
+            preserve_quotes=preserve_quotes,
+            choices=choices,
+            choices_provider=choices_provider,
+            completer=completer,
+            parser=parser,
+        )
+
     def emptyline(self):
         self.onecmd("help")
 
@@ -418,8 +525,8 @@ class SAT_Shell(SAT_Shell_Base):
                 logger.info(f"  Device: {current_device.name}")
                 logger.info(f"  State: {state.value}")
             else:
-                logger.info(f"  Device: No device connected")
-                logger.info(f"  State: unknown")
+                logger.info("  Device: No device connected")
+                logger.info("  State: unknown")
                 
             commands = self.device_driver_manager.get_supported_commands(driver_name)
             if commands:
@@ -448,8 +555,29 @@ def main():
 
     parser = argparse.ArgumentParser(description='SAT Shell entrypoint')
     parser.add_argument('--runserver', action='store_true', help='Start servers directly and keep running until Ctrl+C; on Ctrl+C, stop servers')
+    parser.add_argument(
+        '--log-format',
+        choices=LOG_FORMAT_CHOICES,
+        default=None,
+        help='Set terminal log format. Overrides --plain-log and IOTSPLOIT_LOG_FORMAT.',
+    )
+    parser.add_argument(
+        '--plain-log',
+        action='store_true',
+        help='Use message-only terminal logs unless --log-format is also provided.',
+    )
     args = parser.parse_args()
 
+    selected_log_format = (
+        args.log_format
+        or ("plain" if args.plain_log else None)
+        or os.getenv("IOTSPLOIT_LOG_FORMAT", "standard").strip().lower()
+    )
+    if selected_log_format not in LOG_FORMAT_CHOICES:
+        selected_log_format = "standard"
+    iots_logger.set_format(selected_log_format)
+    logger.set_format(selected_log_format)
+
     shell = SAT_Shell()
     Report_Mgr.Instance().log_init()
     Env_Mgr.Instance().set("SAT_RUN_IN_SHELL", True)
@@ -490,4 +618,3 @@ def main():
 
 if __name__ == '__main__':
     main()
-

iotsploit_cli-0.0.6/PKG-INFO

@@ -1,67 +0,0 @@
-Metadata-Version: 2.3
-Name: iotsploit-cli
-Version: 0.0.6
-Summary: IoTSploit CLI shell (console + command modules) - IoT security testing interactive interface
-License: GPL-3.0-or-later
-Keywords: iot,security,testing,pentest,cli,shell
-Author: IoTSploit Team
-Author-email: support@iotsploit.org
-Requires-Python: >=3.10,<4.0
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Information Technology
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Security
-Classifier: Topic :: System :: Hardware
-Requires-Dist: cmd2 (>=2.4,<3.0)
-Requires-Dist: iotsploit-core (>=0.0.6,<0.0.7)
-Requires-Dist: iotsploit-django (>=0.0.6,<0.0.7)
-Requires-Dist: iotsploit-drivers (>=0.0.6,<0.0.7)
-Requires-Dist: iotsploit-exploits (>=0.0.6,<0.0.7)
-Requires-Dist: iotsploit-mcp (>=0.0.6,<0.0.7)
-Requires-Dist: pwntools (>=4.12,<5.0)
-Project-URL: Documentation, https://www.iotsploit.org/
-Project-URL: Homepage, https://www.iotsploit.org/
-Project-URL: Repository, https://github.com/TKXB/iotsploit
-Description-Content-Type: text/markdown
-
-# iotsploit-cli
-
-IoTSploit interactive CLI shell for IoT security testing.
-
-## Overview
-
-This package provides the `iotsploit` command-line shell built on top of `cmd2`.
-It bundles the core console loop (`console.py`) and all command modules
-(`commands/`) that implement device management, plugin execution, target
-management, network operations, and more.
-
-## Installation
-
-```bash
-pip install iotsploit-cli
-```
-
-## Usage
-
-```bash
-iotsploit
-```
-
-Or with the Django server started immediately:
-
-```bash
-iotsploit --runserver
-```
-
-## License
-
-GPL-3.0-or-later. See [LICENSE](../LICENSE) for details.
-For commercial use, contact wang3919379@gmail.com.
-

iotsploit_cli-0.0.6/README.md

@@ -1,33 +0,0 @@
-# iotsploit-cli
-
-IoTSploit interactive CLI shell for IoT security testing.
-
-## Overview
-
-This package provides the `iotsploit` command-line shell built on top of `cmd2`.
-It bundles the core console loop (`console.py`) and all command modules
-(`commands/`) that implement device management, plugin execution, target
-management, network operations, and more.
-
-## Installation
-
-```bash
-pip install iotsploit-cli
-```
-
-## Usage
-
-```bash
-iotsploit
-```
-
-Or with the Django server started immediately:
-
-```bash
-iotsploit --runserver
-```
-
-## License
-
-GPL-3.0-or-later. See [LICENSE](../LICENSE) for details.
-For commercial use, contact wang3919379@gmail.com.