fh_tool-cli 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

fh_tool_cli/account.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import shlex
 import sys
 from dataclasses import dataclass
+from hashlib import md5
 from secrets import token_urlsafe
 from typing import Any
 
@@ -13,6 +14,8 @@ WEB_ADMIN_PASSWORD_PATH = "InternetGatewayDevice.DeviceInfo.X_CT-COM_TeleComAcco
 TELNET_PASSWORD_PATH = "InternetGatewayDevice.DeviceInfo.X_CT-COM_ServiceManage.TelnetPassword"
 TELNET_USERNAME_PATH = "InternetGatewayDevice.DeviceInfo.X_CT-COM_ServiceManage.TelnetUserName"
 SU_RUNTIME_PASSWORD_FILE = "/var/telsu"
+_MD5_CRYPT_MAGIC = b"$1$"
+_MD5_CRYPT_ALPHABET = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
 
 
 @dataclass(frozen=True)
@@ -69,7 +72,9 @@ def set_telnet_username(backend: CfgCmdBackend, name: str) -> dict[str, Any]:
 
 
 def set_su_runtime_password(shell_runner: Any, password: str) -> dict[str, Any]:
-    command = f"printf %s {shlex.quote(password)} > {shlex.quote(SU_RUNTIME_PASSWORD_FILE)}"
+    hashed_password = _md5_crypt_empty_salt(password)
+    passwd_entry = f"root:{hashed_password}:0:0:Telnet user:/:/bin/ash"
+    command = f"printf '%s\\n' {shlex.quote(passwd_entry)} > {shlex.quote(SU_RUNTIME_PASSWORD_FILE)}"
     shell_runner(command)
     return {
         "path": SU_RUNTIME_PASSWORD_FILE,
@@ -80,6 +85,62 @@ def set_su_runtime_password(shell_runner: Any, password: str) -> dict[str, Any]:
     }
 
 
+def _md5_crypt_empty_salt(password: str) -> str:
+    return _md5_crypt(password.encode(), b"")
+
+
+def _md5_crypt(password: bytes, salt: bytes) -> str:
+    if len(salt) > 8:
+        salt = salt[:8]
+
+    digest = md5(password + _MD5_CRYPT_MAGIC + salt)
+    alternate = md5(password + salt + password).digest()
+    password_len = len(password)
+
+    remaining = password_len
+    while remaining > 0:
+        digest.update(alternate[: min(16, remaining)])
+        remaining -= 16
+
+    remaining = password_len
+    while remaining > 0:
+        if remaining & 1:
+            digest.update(b"\x00")
+        else:
+            digest.update(password[:1])
+        remaining >>= 1
+
+    final = digest.digest()
+    for index in range(1000):
+        digest = md5()
+        digest.update(password if index & 1 else final)
+        if index % 3:
+            digest.update(salt)
+        if index % 7:
+            digest.update(password)
+        digest.update(final if index & 1 else password)
+        final = digest.digest()
+
+    encoded = (
+        _md5_crypt_base64(final[0], final[6], final[12], 4)
+        + _md5_crypt_base64(final[1], final[7], final[13], 4)
+        + _md5_crypt_base64(final[2], final[8], final[14], 4)
+        + _md5_crypt_base64(final[3], final[9], final[15], 4)
+        + _md5_crypt_base64(final[4], final[10], final[5], 4)
+        + _md5_crypt_base64(0, 0, final[11], 2)
+    )
+    return f"$1${salt.decode()}${encoded}"
+
+
+def _md5_crypt_base64(byte2: int, byte1: int, byte0: int, length: int) -> str:
+    value = (byte2 << 16) | (byte1 << 8) | byte0
+    encoded = []
+    for _ in range(length):
+        encoded.append(_MD5_CRYPT_ALPHABET[value & 0x3F])
+        value >>= 6
+    return "".join(encoded)
+
+
 def _redact_write_result(result: dict[str, Any]) -> dict[str, Any]:
     redacted = dict(result)
     redacted["value"] = "[REDACTED]"

fh_tool_cli/backends/cfg_cmd.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import re
 import shlex
 from collections.abc import Callable
@@ -8,6 +9,7 @@ from pathlib import Path
 from typing import Any
 
 from ..errors import CliError
+from ..output import log_event
 
 DANGER_CFG_PATH_RE = re.compile(
     r"(tr-?069|wan|pon|loid|vlan|preconfig|servicelist|smartswitch|cloudplat)",
@@ -57,13 +59,23 @@ class CfgCmdBackend:
         self.expensive_missing_paths = expensive_missing_paths
 
     def get(self, path: str) -> str:
-        return parse_cfg_get_output(path, self._runner(_cfg_command("get", path)))
+        log_event(logging.DEBUG, "cfg.get.start", path=path, risk=cfg_read_risk(path))
+        output = self._runner(_cfg_command("get", path))
+        value = parse_cfg_get_output(path, output)
+        log_event(logging.DEBUG, "cfg.get.success", path=path, risk=cfg_read_risk(path), empty=not bool(value))
+        return value
 
     def set(self, path: str, value: str) -> str:
-        return self._runner(_cfg_command("set", path, value))
+        log_event(logging.INFO, "cfg.set.start", path=path, risk=cfg_path_risk(path))
+        result = self._runner(_cfg_command("set", path, value))
+        log_event(logging.INFO, "cfg.set.success", path=path, risk=cfg_path_risk(path))
+        return result
 
     def attr(self, path: str) -> str:
-        return self._runner(_cfg_command("attr", path)).strip()
+        log_event(logging.DEBUG, "cfg.attr.start", path=path, risk=cfg_read_risk(path))
+        result = self._runner(_cfg_command("attr", path)).strip()
+        log_event(logging.DEBUG, "cfg.attr.success", path=path, risk=cfg_read_risk(path), empty=not bool(result))
+        return result
 
 
 def cfg_set_with_verify(backend: CfgCmdBackend, path: str, value: str) -> dict[str, Any]:

fh_tool_cli/backends/fh_tool.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import logging
 from typing import Any
 
 import requests
@@ -8,6 +9,7 @@ import requests
 from ..config_store import format_mac, resolve_ip, resolve_mac
 from ..crypto import decrypt_payload, derive_crypto, encrypt_payload
 from ..errors import FHToolError
+from ..output import log_event
 
 FH_TOOL_API_PATH = "/fh_tool/api"
 FH_TOOL_UPLOAD_PATH = "/fh_tool/upload"
@@ -22,6 +24,8 @@ def fh_tool_call(
     crypto = derive_crypto(mac)
     encrypted = encrypt_payload(payload, crypto)
     url = f"http://{ip}:8080{FH_TOOL_API_PATH}"
+    func = str(payload.get("func", "unknown"))
+    log_event(logging.INFO, "fh_tool.api.request", ip=ip, path=FH_TOOL_API_PATH, func=func)
     try:
         response = requests.post(
             url,
@@ -34,15 +38,35 @@ def fh_tool_call(
             allow_redirects=False,
         )
     except requests.RequestException as exc:
+        log_event(logging.INFO, "fh_tool.api.error", ip=ip, path=FH_TOOL_API_PATH, func=func, error=str(exc))
         raise FHToolError(f"无法连接 {url}: {exc}") from exc
 
     if response.status_code != 200:
+        log_event(
+            logging.INFO,
+            "fh_tool.api.http_error",
+            ip=ip,
+            path=FH_TOOL_API_PATH,
+            func=func,
+            status_code=response.status_code,
+        )
         raise FHToolError(f"{FH_TOOL_API_PATH} 返回 HTTP {response.status_code}")
 
     try:
-        return decrypt_payload(response.text, crypto)
+        result = decrypt_payload(response.text, crypto)
     except Exception as exc:
+        log_event(logging.INFO, "fh_tool.api.decrypt_error", ip=ip, path=FH_TOOL_API_PATH, func=func)
         raise FHToolError("响应解密失败，MAC 可能不匹配或固件协议不同") from exc
+    log_event(
+        logging.INFO,
+        "fh_tool.api.response",
+        ip=ip,
+        path=FH_TOOL_API_PATH,
+        func=func,
+        status_code=response.status_code,
+        result=result.get("result") if isinstance(result, dict) else None,
+    )
+    return result
 
 
 def api_payload(func: str, params: dict[str, Any] | None = None, index: str = "1") -> dict[str, Any]:

fh_tool_cli/backends/telnet.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import socket
+import logging
 from dataclasses import dataclass
 
 from ..config_store import decode_text
 from ..errors import FHToolError
+from ..output import log_event
 
 
 @dataclass(frozen=True)
@@ -21,6 +23,14 @@ class TelnetShell:
         self.credentials = credentials
 
     def run(self, command: str) -> str:
+        log_event(
+            logging.INFO,
+            "telnet.command.start",
+            host=self.credentials.host,
+            port=self.credentials.port,
+            username_present=bool(self.credentials.username),
+            password_present=bool(self.credentials.password),
+        )
         try:
             with socket.create_connection(
                 (self.credentials.host, self.credentials.port),
@@ -35,10 +45,72 @@ class TelnetShell:
                     sock.sendall(self.credentials.password.encode("utf-8") + b"\n")
                 sock.sendall(command.encode("utf-8") + b"\n")
                 sock.sendall(b"exit\n")
-                return decode_text(_read_all(sock))
+                output = decode_text(_read_all(sock))
+                log_event(
+                    logging.INFO,
+                    "telnet.command.success",
+                    host=self.credentials.host,
+                    port=self.credentials.port,
+                    output_bytes=len(output.encode("utf-8")),
+                )
+                return output
         except OSError as exc:
+            log_event(
+                logging.INFO,
+                "telnet.command.error",
+                host=self.credentials.host,
+                port=self.credentials.port,
+                error=str(exc),
+            )
             raise FHToolError(f"Telnet command failed: {exc}") from exc
 
+    def run_as_root(self, command: str, *, su_password: str) -> str:
+        log_event(
+            logging.INFO,
+            "telnet.root_command.start",
+            host=self.credentials.host,
+            port=self.credentials.port,
+            username_present=bool(self.credentials.username),
+            telnet_password_present=bool(self.credentials.password),
+            su_password_present=bool(su_password),
+        )
+        try:
+            with socket.create_connection(
+                (self.credentials.host, self.credentials.port),
+                timeout=self.credentials.timeout,
+            ) as sock:
+                sock.settimeout(self.credentials.timeout)
+                if self.credentials.username:
+                    _read_until(sock, b"login:")
+                    sock.sendall(self.credentials.username.encode("utf-8") + b"\n")
+                if self.credentials.password:
+                    _read_until(sock, b"Password:")
+                    sock.sendall(self.credentials.password.encode("utf-8") + b"\n")
+                sock.sendall(b"su root\n")
+                _read_until(sock, b"Password:")
+                sock.sendall(su_password.encode("utf-8") + b"\n")
+                sock.sendall(command.encode("utf-8") + b"\n")
+                sock.sendall(b"exit\n")
+                sock.sendall(b"exit\n")
+                output = decode_text(_read_all(sock))
+                log_event(
+                    logging.INFO,
+                    "telnet.root_command.success",
+                    host=self.credentials.host,
+                    port=self.credentials.port,
+                    output_bytes=len(output.encode("utf-8")),
+                )
+                return output
+        except OSError as exc:
+            log_event(
+                logging.INFO,
+                "telnet.root_command.error",
+                host=self.credentials.host,
+                port=self.credentials.port,
+                error=str(exc),
+            )
+            raise FHToolError(f"Telnet root command failed: {exc}") from exc
+
 
 def _read_until(sock: socket.socket, marker: bytes) -> bytes:
     data = bytearray()

fh_tool_cli/backends/web_ajax.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import base64
 import hashlib
+import logging
 import re
 from typing import Any
 from urllib.parse import urljoin
@@ -11,6 +12,7 @@ from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 from cryptography.hazmat.primitives.padding import PKCS7
 
 from ..errors import FHToolError
+from ..output import log_event
 
 DEFAULT_AJAX_PATH = "/cgi-bin/ajax"
 DEFAULT_WEB_LOGIN_PORT = "0"
@@ -65,10 +67,13 @@ class WebAjaxClient:
 
     def login_check(self) -> dict[str, Any]:
         url = self.base_url
+        log_event(logging.INFO, "web.login_check.start", base_url=self.base_url)
         try:
             response = self.session.get(url, timeout=self.timeout, allow_redirects=False)
         except requests.RequestException as exc:
+            log_event(logging.INFO, "web.login_check.error", base_url=self.base_url, error=str(exc))
             raise FHToolError(f"Web login-check failed {url}: {exc}") from exc
+        log_event(logging.INFO, "web.login_check.response", base_url=self.base_url, status_code=response.status_code)
         result = {
             "url": url,
             "status_code": response.status_code,
@@ -112,6 +117,7 @@ class WebAjaxClient:
         *,
         port: str = DEFAULT_WEB_LOGIN_PORT,
     ) -> dict[str, Any]:
+        log_event(logging.INFO, "web.login.start", base_url=self.base_url, username=username)
         brmad = self._fetch_brmad()
         self.ajax_get("get_operator", use_session=False)
         loginpd = fiberhome_web_encrypt(
@@ -128,10 +134,21 @@ class WebAjaxClient:
         )
         response = result.get("response")
         login_result = response.get("login_result") if isinstance(response, dict) else None
+        ok = result["ok"] and str(login_result) == "0"
+        log_event(
+            logging.INFO,
+            "web.login.response",
+            base_url=self.base_url,
+            username=username,
+            status_code=result["status_code"],
+            ok=ok,
+            login_result=login_result,
+            sessionid_present=bool(self.sessionid),
+        )
         return {
             "method": "do_login",
             "status_code": result["status_code"],
-            "ok": result["ok"] and str(login_result) == "0",
+            "ok": ok,
             "login_result": login_result,
             "username": username,
             "sessionid_present": bool(self.sessionid),
@@ -151,6 +168,14 @@ class WebAjaxClient:
             request_params.update(params)
         if use_session and self.sessionid:
             request_params.setdefault("sessionid", self.sessionid)
+        log_event(
+            logging.DEBUG,
+            "web.ajax.request",
+            base_url=self.base_url,
+            http_method="GET",
+            method=method,
+            sessionid_present=bool(request_params.get("sessionid")),
+        )
         try:
             response = self.session.get(
                 url,
@@ -159,6 +184,14 @@ class WebAjaxClient:
                 allow_redirects=False,
             )
         except requests.RequestException as exc:
+            log_event(
+                logging.INFO,
+                "web.ajax.error",
+                base_url=self.base_url,
+                http_method="GET",
+                method=method,
+                error=str(exc),
+            )
             raise FHToolError(f"Web AJAX GET failed {url}: {exc}") from exc
         return self._response_result("GET", url, method, response)
 
@@ -168,6 +201,14 @@ class WebAjaxClient:
         request_data["ajaxmethod"] = method
         if self.sessionid:
             request_data.setdefault("sessionid", self.sessionid)
+        log_event(
+            logging.DEBUG,
+            "web.ajax.request",
+            base_url=self.base_url,
+            http_method="POST",
+            method=method,
+            sessionid_present=bool(request_data.get("sessionid")),
+        )
         try:
             response = self.session.post(
                 url,
@@ -176,6 +217,14 @@ class WebAjaxClient:
                 allow_redirects=False,
             )
         except requests.RequestException as exc:
+            log_event(
+                logging.INFO,
+                "web.ajax.error",
+                base_url=self.base_url,
+                http_method="POST",
+                method=method,
+                error=str(exc),
+            )
             raise FHToolError(f"Web AJAX POST failed {url}: {exc}") from exc
         return self._response_result("POST", url, method, response)
 
@@ -319,6 +368,16 @@ class WebAjaxClient:
             "content_type": response.headers.get("Content-Type"),
             "sessionid_present": bool(self.sessionid),
         }
+        log_event(
+            logging.DEBUG,
+            "web.ajax.response",
+            base_url=self.base_url,
+            http_method=http_method,
+            method=method,
+            status_code=response.status_code,
+            ok=result["ok"],
+            sessionid_present=bool(self.sessionid),
+        )
         try:
             payload = response.json()
         except ValueError:

fh_tool_cli/backup.py

@@ -23,13 +23,30 @@ BACKUP_PATHS = [
     "/fhconf/status_version_flag",
     "/fhconf/cfgmgr_restore_flag_conf",
     "/fhconf/factory_reset_conf",
+    "/fhconf/fhcfgmonitor.conf",
+    "/fhconf/fac_process_start_list",
+    "/fhconf/u_config_conf",
     "/fhconf/process_start_list",
+    "/fhconf/process_monitor_list",
+    "/fhconf/normal_reboot_flag",
+    "/fhconf/crc_file",
+    "/fhconf/usrconfig_dl_conf",
+    "/fhconf/usrconfig_dl_flag",
+    "/fhconf/gdecms/gdecms_conf",
     "/fhconf/tr069_control_conf",
     "/fhconf/xpon_tr069cfg_conf",
     "/fhdata/factory_conf",
     "/fhdata/sysinfo_conf",
     "/fhdata/pre_usrconfig_conf",
     "/fhdata/pre_attrconfig_conf",
+    "/fhdata/tr069_control_conf",
+    "/fhdata/voice_digitmap_conf",
+    "/fhdata/factorymodeflag",
+    "/opt/upt/apps/info/reboot_info",
+    "/opt/upt/apps/info/crash_info",
+    "/opt/upt/apps/mtd.booting",
+    "/opt/upt/apps/upt.mtd",
+    "/opt/upt/apps/saf-upgradeinfo",
     "/var/tel_passwd",
     "/var/telWan_passwd",
     "/var/telsu",

fh_tool_cli/cli.py

@@ -299,7 +299,7 @@ def command_restore_backup(args: argparse.Namespace) -> dict[str, Any]:
     if args.target == "device":
         result = restore_backup_to_device(
             Path(args.backup).expanduser(),
-            shell_runner=_telnet_shell_from_args(args).run,
+            shell_runner=_telnet_root_shell_runner_from_args(args),
             dry_run=dry_run,
             paths=args.path,
             remote_tmpdir=args.remote_tmpdir,
@@ -380,6 +380,36 @@ def _telnet_shell_from_args(args: argparse.Namespace) -> TelnetShell:
     return TelnetShell(_telnet_credentials_from_args(args))
 
 
+def _telnet_root_shell_runner_from_args(args: argparse.Namespace) -> Callable[[str], str]:
+    if getattr(args, "backend", "telnet") == "local-vm":
+        return LocalVmShell(
+            Path(args.vm_root).expanduser(),
+            timeout=args.timeout,
+        ).run
+    ip, _ip_source = resolve_ip(args)
+    su_password = _current_su_password_from_args(args, ip=ip)
+    shell = _telnet_shell_from_args(args)
+
+    def run(command: str) -> str:
+        return shell.run_as_root(command, su_password=su_password)
+
+    return run
+
+
+def _current_su_password_from_args(args: argparse.Namespace, *, ip: str) -> str:
+    has_password = getattr(args, "su_password", None) is not None
+    has_stdin = getattr(args, "su_password_stdin", False)
+    if has_password and has_stdin:
+        raise CliError("当前 su root 密码只能选择 --su-password 或 --su-password-stdin")
+    if has_stdin:
+        if getattr(args, "password_stdin", False) or getattr(args, "telnet_password_stdin", False):
+            raise CliError("--su-password-stdin 不能和其它 stdin 密码选项同时使用")
+        return sys.stdin.readline().rstrip("\n")
+    if has_password:
+        return str(args.su_password)
+    return derive_hg5143f_su_password_from_args(args, ip=ip)
+
+
 def _shell_runner_from_args(args: argparse.Namespace) -> Callable[[str], str]:
     if getattr(args, "backend", "telnet") == "local-vm":
         return LocalVmShell(
@@ -516,7 +546,7 @@ def command_account_set_su_runtime_password(args: argparse.Namespace) -> dict[st
             side_effects={"runtime_password_write": False},
         )
     secret, password_source = _su_runtime_password_from_args(args)
-    result = set_su_runtime_password(_telnet_shell_from_args(args).run, secret.password)
+    result = set_su_runtime_password(_telnet_root_shell_runner_from_args(args), secret.password)
     result["generated"] = secret.generated
     result["password_source"] = password_source
     return result
@@ -570,10 +600,10 @@ def command_autoupdate_plan(args: argparse.Namespace) -> dict[str, Any]:
 
 
 def command_tr069_status(args: argparse.Namespace) -> dict[str, Any]:
-    shell = _telnet_shell_from_args(args)
+    shell_runner = _telnet_root_shell_runner_from_args(args)
     return tr069_status(
         _cfg_backend_from_args(args),
-        shell.run,
+        shell_runner,
         reveal_secrets=args.reveal_secrets,
     )
 
@@ -624,10 +654,10 @@ def command_tr069_randomize_connection_request(args: argparse.Namespace) -> dict
 
 
 def command_cloud_status(args: argparse.Namespace) -> dict[str, Any]:
-    shell = _telnet_shell_from_args(args)
+    shell_runner = _telnet_root_shell_runner_from_args(args)
     return cloud_status(
         _cfg_backend_from_args(args),
-        shell.run,
+        shell_runner,
         reveal_secrets=args.reveal_secrets,
     )
 
@@ -659,7 +689,7 @@ def command_cloud_disable_cloudclt(args: argparse.Namespace) -> dict[str, Any]:
             "cloud disable-cloudclt 会停止/禁用 cloud client",
             side_effects={"shell_write": False, "service_stop": False},
         )
-    return cloud_disable_cloudclt(_telnet_shell_from_args(args).run)
+    return cloud_disable_cloudclt(_telnet_root_shell_runner_from_args(args))
 
 
 def command_cloud_disable_smartswitch(args: argparse.Namespace) -> dict[str, Any]:
@@ -686,7 +716,7 @@ def command_vlan_list(args: argparse.Namespace) -> dict[str, Any]:
 
 
 def command_ip_status(args: argparse.Namespace) -> dict[str, Any]:
-    return ip_status(_shell_runner_from_args(args))
+    return ip_status(_telnet_root_shell_runner_from_args(args))
 
 
 def command_firewall_status(args: argparse.Namespace) -> dict[str, Any]:

fh_tool_cli/click_cli.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import logging
 import sys
 from types import SimpleNamespace
 from typing import Any, Callable
@@ -8,7 +9,7 @@ from typing import Any, Callable
 import click
 
 from .errors import CliError, FHToolError
-from .output import configure_logging, emit, emit_cancelled, emit_error
+from .output import configure_logging, emit, emit_cancelled, emit_error, log_event
 from .parser import HandlerMap, build_parser
 
 
@@ -150,11 +151,7 @@ def _command_from_parser(
 def _parent_callback(fixed: dict[str, Any]) -> Callable[..., None]:
     @click.pass_context
     def callback(ctx: click.Context, **kwargs: Any) -> None:
-        configure_logging(
-            verbose=int(kwargs.pop("verbose", 0) or 0),
-            quiet=int(kwargs.pop("quiet", 0) or 0),
-            log_file=kwargs.pop("log_file", None),
-        )
+        _configure_logging_from_kwargs(kwargs)
         state = ctx.ensure_object(dict)
         state.update(fixed)
         state.update(_normalize_click_values(kwargs))
@@ -165,11 +162,7 @@ def _parent_callback(fixed: dict[str, Any]) -> Callable[..., None]:
 def _group_callback(parser: argparse.ArgumentParser, fixed: dict[str, Any]) -> Callable[..., int | None]:
     @click.pass_context
     def callback(ctx: click.Context, **kwargs: Any) -> int | None:
-        configure_logging(
-            verbose=int(kwargs.pop("verbose", 0) or 0),
-            quiet=int(kwargs.pop("quiet", 0) or 0),
-            log_file=kwargs.pop("log_file", None),
-        )
+        _configure_logging_from_kwargs(kwargs)
         state = ctx.ensure_object(dict)
         state.update(fixed)
         state.update(_normalize_click_values(kwargs))
@@ -191,6 +184,16 @@ def _leaf_callback(parser: argparse.ArgumentParser, fixed: dict[str, Any]) -> Ca
     return callback
 
 
+def _configure_logging_from_kwargs(kwargs: dict[str, Any]) -> None:
+    if not {"verbose", "quiet", "log_file"} & set(kwargs):
+        return
+    configure_logging(
+        verbose=int(kwargs.pop("verbose", 0) or 0),
+        quiet=int(kwargs.pop("quiet", 0) or 0),
+        log_file=kwargs.pop("log_file", None),
+    )
+
+
 def _run_parser_handler(parser: argparse.ArgumentParser, values: dict[str, Any]) -> int:
     args_values = dict(parser._defaults)
     args_values.update(values)
@@ -198,16 +201,30 @@ def _run_parser_handler(parser: argparse.ArgumentParser, values: dict[str, Any])
     if handler is None:
         raise FHToolClickError("missing command handler")
     args = SimpleNamespace(**args_values)
+    handler_name = getattr(handler, "__name__", handler.__class__.__name__)
+    command = _command_name(args_values)
 
     try:
+        log_event(logging.DEBUG, "cli.command.start", command=command, handler=handler_name)
         result = handler(args)
     except (argparse.ArgumentTypeError, CliError, FHToolError, ValueError) as exc:
+        log_event(logging.INFO, "cli.command.error", command=command, handler=handler_name, error=str(exc))
         raise FHToolClickError(str(exc)) from exc
 
     emit(result, bool(getattr(args, "json", False)))
+    log_event(logging.DEBUG, "cli.command.success", command=command, handler=handler_name)
     return 0
 
 
+def _command_name(values: dict[str, Any]) -> str:
+    parts = [
+        value
+        for key, value in values.items()
+        if key == "command" or key.endswith("_command")
+    ]
+    return " ".join(str(part) for part in parts if part) or "root"
+
+
 def _normalize_click_values(values: dict[str, Any]) -> dict[str, Any]:
     normalized: dict[str, Any] = {}
     for key, value in values.items():

fh_tool_cli/client.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import socket
 from pathlib import Path
 from typing import Any
@@ -8,13 +9,17 @@ from urllib.parse import urljoin
 import requests
 
 from .errors import FHToolError
+from .output import log_event
 
 
 def tcp_open(ip: str, port: int, timeout: float) -> bool:
+    log_event(logging.DEBUG, "tcp.probe.start", ip=ip, port=port)
     try:
         with socket.create_connection((ip, port), timeout=timeout):
+            log_event(logging.DEBUG, "tcp.probe.result", ip=ip, port=port, open=True)
             return True
     except OSError:
+        log_event(logging.DEBUG, "tcp.probe.result", ip=ip, port=port, open=False)
         return False
 
 
@@ -26,20 +31,32 @@ def make_download_url(ip: str, value: str) -> str:
 
 def download_to_file(ip: str, url_value: str, output: Path, timeout: float) -> dict[str, Any]:
     url = make_download_url(ip, url_value)
+    log_event(logging.INFO, "download.start", url=url, output=str(output))
     try:
         response = requests.get(url, timeout=timeout, stream=True)
     except requests.RequestException as exc:
+        log_event(logging.INFO, "download.error", url=url, output=str(output), error=str(exc))
         raise FHToolError(f"下载失败 {url}: {exc}") from exc
     if response.status_code != 200:
+        log_event(logging.INFO, "download.http_error", url=url, output=str(output), status_code=response.status_code)
         raise FHToolError(f"下载失败 {url}: HTTP {response.status_code}")
     output.parent.mkdir(parents=True, exist_ok=True)
     with output.open("wb") as file:
         for chunk in response.iter_content(chunk_size=1024 * 128):
             if chunk:
                 file.write(chunk)
+    bytes_written = output.stat().st_size
+    log_event(
+        logging.INFO,
+        "download.success",
+        url=url,
+        output=str(output),
+        bytes=bytes_written,
+        content_type=response.headers.get("Content-Type"),
+    )
     return {
         "url": url,
         "output": str(output),
-        "bytes": output.stat().st_size,
+        "bytes": bytes_written,
         "content_type": response.headers.get("Content-Type"),
     }

fh_tool_cli/commands/web.py

@@ -81,10 +81,10 @@ def _web_login_if_requested(
     explicit_secret = getattr(args, "password", None) is not None or getattr(args, "password_stdin", False)
     explicit_username = getattr(args, "username", None) is not None
     explicit_source = password_source != "auto"
-    if client.sessionid and force_auto and not (explicit_secret or explicit_username or explicit_source):
+    if _has_explicit_web_sessionid(args) and force_auto and not (explicit_secret or explicit_source):
         return {
             "attempted": False,
-            "username": DEFAULT_WEB_USERNAME,
+            "username": getattr(args, "username", None) or DEFAULT_WEB_USERNAME,
             "password_source": "sessionid",
             "sessionid_present": True,
         }
@@ -95,6 +95,8 @@ def _web_login_if_requested(
     password, source, errors = _web_password_from_args(args)
     if password is None:
         if password_source == "none":
+            if require_success and not client.sessionid:
+                raise CliError("Web login 需要密码或显式 --sessionid")
             return {
                 "attempted": False,
                 "username": username,
@@ -112,11 +114,23 @@ def _web_login_if_requested(
             "error": error,
         }
 
-    result = client.login(
-        username,
-        password,
-        port=getattr(args, "web_login_port", DEFAULT_WEB_LOGIN_PORT),
-    )
+    try:
+        result = client.login(
+            username,
+            password,
+            port=getattr(args, "web_login_port", DEFAULT_WEB_LOGIN_PORT),
+        )
+    except FHToolError as exc:
+        if require_success:
+            raise CliError(f"Web login failed: {exc}") from exc
+        return {
+            "attempted": True,
+            "username": username,
+            "password_source": source,
+            "sessionid_present": bool(client.sessionid),
+            "ok": False,
+            "error": str(exc),
+        }
     result["attempted"] = True
     result["password_source"] = source
     if require_success and not result["ok"]:
@@ -126,6 +140,10 @@ def _web_login_if_requested(
     return result
 
 
+def _has_explicit_web_sessionid(args: argparse.Namespace) -> bool:
+    return getattr(args, "sessionid", None) is not None
+
+
 def _web_password_from_args(args: argparse.Namespace) -> tuple[str | None, str, list[str]]:
     has_password = getattr(args, "password", None) is not None
     has_stdin = getattr(args, "password_stdin", False)
@@ -263,8 +281,10 @@ def command_web_login_check(args: argparse.Namespace) -> dict[str, Any]:
 
 def command_web_ajax_get(args: argparse.Namespace) -> dict[str, Any]:
     client = _web_client_from_args(args)
-    _web_login_if_requested(client, args)
-    return client.ajax_get(args.method)
+    login_result = _web_read_login(client, args)
+    result = client.ajax_get(args.method)
+    result["login"] = _auth_summary(login_result)
+    return result
 
 
 def command_web_ajax_post(args: argparse.Namespace) -> dict[str, Any]:
@@ -453,6 +473,10 @@ def _auth_summary(auth: dict[str, Any] | None) -> dict[str, Any]:
     return summary
 
 
+def _web_read_login(client: WebAjaxClient, args: argparse.Namespace) -> dict[str, Any] | None:
+    return _web_login_if_requested(client, args, require_success=False, force_auto=True)
+
+
 def _require_lan_target(args: argparse.Namespace) -> None:
     ip, _ip_source = resolve_ip(args)
     address = ipaddress.ip_address(ip)
@@ -464,15 +488,17 @@ def _require_lan_target(args: argparse.Namespace) -> None:
 def command_web_typed(group: str, action: str) -> Callable[[argparse.Namespace], dict[str, Any]]:
     def handler(args: argparse.Namespace) -> dict[str, Any]:
         client = _web_client_from_args(args)
-        _web_login_if_requested(client, args)
-        return client.typed(group, action)
+        login_result = _web_read_login(client, args)
+        result = client.typed(group, action)
+        result["login"] = _auth_summary(login_result)
+        return result
 
     return handler
 
 
 def command_web_diagnostics_show(args: argparse.Namespace) -> dict[str, Any]:
     client = _web_client_from_args(args)
-    _web_login_if_requested(client, args)
+    login_result = _web_read_login(client, args)
     requested = args.view or [
         "wan",
         "port-mapping",
@@ -501,6 +527,7 @@ def command_web_diagnostics_show(args: argparse.Namespace) -> dict[str, Any]:
             "errors": errors,
             "partial_failure": bool(errors),
             "sessionid_present": bool(client.sessionid),
+            "login": _auth_summary(login_result),
         }
     }
 
@@ -517,8 +544,12 @@ def command_web_typed_write(group: str, action: str) -> Callable[[argparse.Names
         if not payload:
             raise CliError("Web AJAX write 需要 typed 参数、--param 或 --json-payload")
         client = _web_client_from_args(args)
-        _web_login_if_requested(client, args)
+        login_result = None
+        if not dry_run:
+            login_result = _web_login_if_requested(client, args, require_success=True, force_auto=True)
         result = client.typed_write(group, action, payload, dry_run=dry_run)
+        if login_result is not None:
+            result["login"] = _auth_summary(login_result)
         if dry_run:
             result["plan"] = {"execute_requires": ["--confirm"]}
             result.update(dry_run_notice())

fh_tool_cli/output.py

@@ -2,12 +2,38 @@ from __future__ import annotations
 
 import json
 import logging
+import re
 import sys
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
 from rich.console import Console
 
+SENSITIVE_LOG_KEY_RE = re.compile(
+    r"(sessionid|token|password|passwd|pwd|loginpd|loid|pppoe|acs|secret|psk|wepkey|wpakey|regpwd)",
+    re.IGNORECASE,
+)
+
+
+class StructuredLogFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        event = getattr(record, "event", None)
+        fields = getattr(record, "structured_fields", None)
+        payload: dict[str, Any] = {
+            "timestamp": datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z"),
+            "level": record.levelname.lower(),
+            "logger": record.name,
+            "message": record.getMessage(),
+        }
+        if event:
+            payload["event"] = event
+        if isinstance(fields, dict):
+            payload.update(fields)
+        if record.exc_info:
+            payload["exception"] = self.formatException(record.exc_info)
+        return json.dumps(payload, ensure_ascii=False, sort_keys=True)
+
 
 def configure_logging(*, verbose: int = 0, quiet: int = 0, log_file: str | None = None) -> None:
     level = logging.WARNING
@@ -24,14 +50,40 @@ def configure_logging(*, verbose: int = 0, quiet: int = 0, log_file: str | None
         path.parent.mkdir(parents=True, exist_ok=True)
         handlers.append(logging.FileHandler(path, encoding="utf-8"))
 
+    formatter = StructuredLogFormatter()
+    for handler in handlers:
+        handler.setFormatter(formatter)
+
     logging.basicConfig(
         level=level,
-        format="%(levelname)s %(name)s: %(message)s",
         handlers=handlers,
         force=True,
     )
 
 
+def log_event(level: int, event: str, **fields: Any) -> None:
+    logging.getLogger("fh_tool_cli").log(
+        level,
+        event,
+        extra={
+            "event": event,
+            "structured_fields": redact_log_fields(fields),
+        },
+    )
+
+
+def redact_log_fields(value: Any, *, key: str | None = None) -> Any:
+    if key is not None and SENSITIVE_LOG_KEY_RE.search(key):
+        return "[REDACTED]"
+    if isinstance(value, dict):
+        return {str(item_key): redact_log_fields(item, key=str(item_key)) for item_key, item in value.items()}
+    if isinstance(value, list):
+        return [redact_log_fields(item) for item in value]
+    if isinstance(value, tuple):
+        return [redact_log_fields(item) for item in value]
+    return value
+
+
 def emit(data: Any, json_mode: bool) -> None:
     if json_mode or isinstance(data, dict):
         sys.stdout.write(json.dumps(data, ensure_ascii=False, indent=2) + "\n")

fh_tool_cli/parser.py

@@ -125,6 +125,8 @@ def add_telnet_options(
         action="store_true",
         help="关闭默认 HG5143F 派生 Telnet 凭据 fallback",
     )
+    parser.add_argument("--su-password", help="当前 su root 密码；未提供时默认使用 HG5143F 派生候选")
+    parser.add_argument("--su-password-stdin", action="store_true", help="从 stdin 读取当前 su root 密码")
 
 
 def add_cfg_backend_options(parser: argparse.ArgumentParser) -> None:

fh_tool_cli/remote.py

@@ -36,6 +36,7 @@ CLOUD_ENDPOINT_PATHS = {
 CLOUD_PROCESSES = ("gdecms", "saf", "appmgr", "cloudclient", "cloudclocal", "cloudclt")
 SMARTSWITCH_PATH = CLOUD_ENDPOINT_PATHS["smart_switch"]
 SMARTSWITCH_DISABLED_VALUE = "0"
+SMARTSWITCH_CONFIRMED_STORAGE_PATH = "/fhdata/sysinfo_conf"
 SMARTSWITCH_IMPACT = [
     "Blocks SAF/appframework cloud integration paths controlled by SmartSwitch.",
     "May affect operator cloud management features exposed through CloudPlat.",
@@ -159,6 +160,8 @@ def remote_plan(kind: str) -> dict[str, Any]:
                 "description": "Set SmartSwitch=0 to block SAF/appframework.",
                 "path": SMARTSWITCH_PATH,
                 "target_value": SMARTSWITCH_DISABLED_VALUE,
+                "confirmed_storage_path": SMARTSWITCH_CONFIRMED_STORAGE_PATH,
+                "storage_path_basis": "research_confirmed",
                 "impact": SMARTSWITCH_IMPACT,
                 "forbidden_changes": SMARTSWITCH_FORBIDDEN_CHANGES,
                 "device_write": True,
@@ -205,13 +208,27 @@ def tr069_randomize_connection_request(backend: CfgCmdBackend) -> dict[str, Any]
 
 
 def cloud_disable_cloudclt(shell_runner: Any) -> dict[str, Any]:
-    command = "cloudclt stop 2>/dev/null || /etc/init.d/cloudclt stop 2>/dev/null || true"
-    output = shell_runner(command)
+    commands = [
+        "lxc-attach -n saf -- /etc/init.d/cloudclt stop 2>&1 || true",
+        "lxc-attach -n saf -- /etc/init.d/cloudclt disable 2>&1 || true",
+    ]
+    command_results = [
+        {
+            "command": command,
+            "output": str(shell_runner(command)),
+        }
+        for command in commands
+    ]
     return {
         "action": "disable-cloudclt",
         "risk": "danger",
-        "command": command,
-        "output": str(output),
+        "target": {
+            "container": "saf",
+            "service": "cloudclt",
+        },
+        "command": " && ".join(commands),
+        "output": "\n".join(result["output"] for result in command_results),
+        "commands": command_results,
     }
 
 
@@ -226,6 +243,8 @@ def cloud_disable_smartswitch(backend: CfgCmdBackend) -> dict[str, Any]:
         "risk": "danger",
         "path": SMARTSWITCH_PATH,
         "target_value": SMARTSWITCH_DISABLED_VALUE,
+        "confirmed_storage_path": SMARTSWITCH_CONFIRMED_STORAGE_PATH,
+        "storage_path_basis": "research_confirmed",
         "impact": SMARTSWITCH_IMPACT,
         "forbidden_changes": SMARTSWITCH_FORBIDDEN_CHANGES,
         "write": {
@@ -258,6 +277,8 @@ def _smart_switch_status(status: dict[str, Any]) -> dict[str, Any]:
     result: dict[str, Any] = {
         "path": SMARTSWITCH_PATH,
         "disable_value": SMARTSWITCH_DISABLED_VALUE,
+        "confirmed_storage_path": SMARTSWITCH_CONFIRMED_STORAGE_PATH,
+        "storage_path_basis": "research_confirmed",
         "risk": "danger",
         "impact": SMARTSWITCH_IMPACT,
         "forbidden_changes": SMARTSWITCH_FORBIDDEN_CHANGES,

{fh_tool_cli-0.2.2.dist-info → fh_tool_cli-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fh_tool-cli
-Version: 0.2.2
+Version: 0.2.3
 Summary: 用于本地管理 FiberHome fh_tool 接口的 Python CLI
 Author: Gxxk
 License-Expression: AGPL-3.0-or-later
@@ -52,6 +52,8 @@ fh-tool --log-file fh-tool.log dev-info
 
 `--json` 输出稳定的 machine-readable JSON，不混入日志或样式。当前默认人类输出仍保持 pretty JSON，以兼容已有脚本；后续可以在不影响 `--json` 的前提下逐步增加表格化输出。
 
+`--log-file` 写入 JSON lines 结构化日志；`-v/-vv` 控制 info/debug 事件，`-q` 只保留 error 级别。日志只记录 command、HTTP method、状态码、cfg path、风险等级等元数据，密码、session、token、LOID、PPPoE 等字段会脱敏。
+
 ## 快速配置
 
 保存默认 IP/MAC：
@@ -149,7 +151,7 @@ fh-tool wan list --backend local-vm
 
 `local-vm` 只是在本机 proot VM 内执行厂商 `cfg_cmd`。`--vm-root` 必须指向 VM 工作区目录，也就是包含 `bin/proot-shell` 和 `rootfs-vm/fhrom/bin/cfg_cmd` 的目录；默认是 `/mnt/dev-cold/HG5143F-ONU-vm`。不要把它指到里面的 `rootfs-vm/`。
 
-Web AJAX 读取命令只读。需要复用已有 Web session 时加 `--sessionid`；需要登录时可显式传 `--password-stdin` 或 `--password`。未显式提供密码时默认 `--username useradmin --password-source auto`，会依次尝试 `GetAdminAccount` 和 cfg 路径读取 Web superadmin 密码；cfg 来源需要 Telnet 时会默认使用 HG5143F 派生 Telnet 凭据 fallback，可用 `--no-derived-credentials` 关闭。失败不会阻塞只读抓取。sessionid、密码、LOID、PPPoE 等敏感字段默认会脱敏；只有显式加 `--reveal-secrets` 才输出明文。
+Web AJAX 读取命令只读。需要复用已有 Web session 时加 `--sessionid`；需要登录时可显式传 `--password-stdin` 或 `--password`。未显式提供密码时默认 `--username useradmin --password-source auto`，会依次尝试 `GetAdminAccount` 和 cfg 路径读取 Web superadmin 密码；cfg 来源需要 Telnet 时会默认使用 HG5143F 派生 Telnet 凭据 fallback，可用 `--no-derived-credentials` 关闭。失败不会阻塞只读抓取，并会在结果里返回脱敏 login summary。sessionid、密码、LOID、PPPoE 等敏感字段默认会脱敏；只有显式加 `--reveal-secrets` 才输出明文。
 
 后台 AJAX 接口发现以 live discovery 为主路径，不需要 HAR，也不需要 rootfs：
 
@@ -174,6 +176,8 @@ fh-tool web services set --service telnet --enabled 0 --confirm
 
 常规 Web 写接口优先使用 typed 参数。`web ajax post` 和 `web ajax replay` 支持任意已知或未知 AJAX method，默认只输出计划，不发 POST；执行必须加 `--confirm`，且默认拒绝空 payload。`--json-payload` 和可重复的 `--param k=v` 仍保留为固件差异逃生口，合并顺序是 typed 参数、JSON、最后 `--param` 覆盖。旧的确认参数会直接报弃用错误。
 
+Web AJAX 写命令 dry-run 不会登录；加 `--confirm` 后，如果没有显式 `--sessionid`，会要求自动登录成功后才发 POST。
+
 Telnet/cfg/诊断命令在未显式传 Telnet 密码时，会默认使用 HG5143F 派生 Telnet 凭据 fallback；显式传入的用户名/密码始终优先。如果设备不是该规则，或需要保留空凭据/自定义认证，可加 `--no-derived-credentials` 关闭。`--use-derived-credentials` 仍作为兼容参数接受：
 
 ```bash
@@ -182,6 +186,8 @@ fh-tool wan list
 fh-tool cfg get InternetGatewayDevice.DeviceInfo.Manufacturer --no-derived-credentials
 ```
 
+需要 root shell 的 Telnet 操作会自动执行 `su root`，当前 su 密码默认按 HG5143F 规则从 MAC 派生；如果 runtime su 密码已经被你改过，可显式传 `--su-password` 或 `--su-password-stdin`。例如 device restore、`cloud disable-cloudclt --confirm`、`account set-su-runtime-password --confirm` 会走 root runner。`account set-su-runtime-password` 写入的是 `/var/telsu` 的 passwd 格式 md5-crypt 行，不会把明文密码写入远端命令。
+
 诊断命令保持只读；`ip status` 这类依赖 VM/userspace 工具的命令会分别标记每个 probe 的 `ok/output/error`，工具缺失时输出 `partial_failure=true`，不会吞掉其它已成功字段。
 
 本地 VM 集成测试默认会跳过；需要显式指定 VM 目录才会运行：
@@ -226,6 +232,8 @@ fh-tool restore backup.tgz \
 
 当前 restore 只恢复 allowlist 内的配置文件，且会拒绝路径穿越、绝对路径逃逸和未知文件写入。`/proc/mtd`、runtime password 文件、restore/factory reset flag 等备份内容不会被恢复。恢复后会 read-back/hash verify；不会自动 reboot，也不会自动 factory reset。
 
+默认备份清单包含调研确认的 `/fhconf`、`/fhdata`、runtime password、CloudPlat/appframework 状态和 boot/app 信息等只读路径；这些新增调研路径不会自动加入 restore allowlist。
+
 ## CloudPlat / SmartSwitch
 
 CloudPlat 默认先做只读审计和计划：
@@ -244,6 +252,14 @@ fh-tool cloud disable-smartswitch --confirm
 
 该命令不会修改 LOID、PON、WAN VLAN、ServiceList 或 TR-069 VLAN。
 
+只停 CloudPlat 连接优先使用 SAF container 内的 `cloudclt` init 脚本：
+
+```bash
+fh-tool cloud disable-cloudclt --confirm
+```
+
+该命令通过 `lxc-attach -n saf -- /etc/init.d/cloudclt stop/disable` 执行，需要 root runner；仍然不会 patch 启动脚本或删除 package。
+
 ## 22 个 `/fh_tool/api` method 覆盖
 
 已提供 typed command：

{fh_tool_cli-0.2.2.dist-info → fh_tool_cli-0.2.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
 fh_tool_cli/__init__.py,sha256=QWxyrUwVq3pHukey6kpMjqRKbzi5ksTU-gvnTqEoAkE,72
-fh_tool_cli/account.py,sha256=-m3yctePqJ3JXeWcw-zcw_CJSymccF2mmH469IToqpw,3165
+fh_tool_cli/account.py,sha256=l-qNkDao3FdSN2VASqBHsHYLLVl4L9Hx4JfE1m8s8tQ,5150
 fh_tool_cli/argparse_utils.py,sha256=ntjr5O8H-GbFEUvZKHf-0NbRy0N4-lS6YRXbMQ6fbA4,1640
-fh_tool_cli/backup.py,sha256=eR4_3NcfizZwVznF8IBh8lGotkKX50edLCMxvx6XWYg,24024
-fh_tool_cli/cli.py,sha256=Hy0OYr3pjEHnIUwzW-oauPyXkYUKNHKoz1jqrWtynC4,34332
-fh_tool_cli/click_cli.py,sha256=AYQggSPJHXz4owmW1Rt34e3qKjdlawYSkMMO8qrwYRw,9579
-fh_tool_cli/client.py,sha256=rahXuj5pkmkJO2R-cTp9D8qt9bFexwfqJSn7HpjO0_I,1396
+fh_tool_cli/backup.py,sha256=ywoim97pa11DO7KuqcTptMEQha9ENsmTyiQD9_Lgdkc,24592
+fh_tool_cli/cli.py,sha256=o9WGZPKfM4siIjzjMXPvsfUhUz1sKY9uuL5sZpdiNYA,35667
+fh_tool_cli/click_cli.py,sha256=voxEuVPUth88wcDd-XqJPMHYcuTi6bZCqqWFR-3q1ZQ,10286
+fh_tool_cli/client.py,sha256=-59Zvn3S5DREtxOuu2iXCbnpmCEpbi2csKA2X3XUwFY,2202
 fh_tool_cli/config_decrypt.py,sha256=mB0OXF4b9GgSKkHKwu_U1POih2Z1IUfOwBxLXjstEaE,9519
 fh_tool_cli/config_store.py,sha256=BK0H_lGWHZp6P8gH9Uc70emHNnjC6yQ7Lile8Zy5WGo,5257
 fh_tool_cli/credential_sources.py,sha256=kZ94LTylk4i3hQRvQiG7eAe9N8u6oiWenxRFBJA_f2U,1495
@@ -12,23 +12,23 @@ fh_tool_cli/credentials.py,sha256=xVSbFxX9xD5X5BPCNiVJEDvwk_iVf3q0hnLDcBR02mw,31
 fh_tool_cli/crypto.py,sha256=8hbR5q451_sX4OoQ59c0pKs33H8CKezpE40ZYGbgNc8,2151
 fh_tool_cli/diagnostics.py,sha256=f5snLEn7SugQrzOZIyWM8SwceCCiUSfhLHeiUdgfTs4,19669
 fh_tool_cli/errors.py,sha256=_JI5_p1or7PnMw1CV6mVpmDbAgTWy06ysmdoAEu54l0,120
-fh_tool_cli/output.py,sha256=hi3-rVcKwEPxSuUjaoUZsZeDbh3VreRQJOL5tV3v8a8,1287
-fh_tool_cli/parser.py,sha256=5L_S8ZCGlokNQnoAcMoS_riPKmw6YAVoL3Vt6670SpI,34227
-fh_tool_cli/remote.py,sha256=z_YqNLvIoha3iimf1Ce1DZ4y-6xGqXJql7Xv8uDUvOA,9704
+fh_tool_cli/output.py,sha256=3XD1j7KGGHjtxfuFr6ptkT9k4cZe7uY3WvgRgBxKT-c,3108
+fh_tool_cli/parser.py,sha256=eytzdJWl5VpH1--scUf8HSVsmCi7B35axaziq3XuK1k,34460
+fh_tool_cli/remote.py,sha256=N6c1LcJJ9itjufCdULdzgFeMxCH8e_o7uNPQ-QnQngM,10547
 fh_tool_cli/risk.py,sha256=9sKCGE3uiNR-1ylzJbm0ryICVju12VQxia2gp-FRxFA,1270
 fh_tool_cli/upload.py,sha256=13L2Dgn3_1l5rkTGzCuxk4Jr0R15vdSVF9A40A44WHk,7442
 fh_tool_cli/web_discovery.py,sha256=Ud8_p78-Fx1fVa3u4w3apYkKh-0yg8YNx745iGiBDm4,23393
 fh_tool_cli/web_writes.py,sha256=H7zRMYJggl8qFu9e4KQW5k-KOZke4qVh2sHbwxqaABY,12917
 fh_tool_cli/backends/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
-fh_tool_cli/backends/cfg_cmd.py,sha256=zvK5O-utBBplvqOZyJhuqiMvu_qZ8Pgn6aDvNXbLty8,3992
-fh_tool_cli/backends/fh_tool.py,sha256=bwn21rXyU4Qs4_KBHPaZKP8f1CEdogE21manisJ1nOw,2335
+fh_tool_cli/backends/cfg_cmd.py,sha256=WFdO0M9Qu7OndkgfAAYp5Z9EgL2IOUBGTK-_hxDqFPM,4707
+fh_tool_cli/backends/fh_tool.py,sha256=i5VPAwe7ksjSu0QZbgjItzya0x1BR108y-UuIO48bv4,3225
 fh_tool_cli/backends/local_vm.py,sha256=kSgHVplCViK8L6mOOttj85BjGPHFUFMzwmXjlIPIdO0,2433
-fh_tool_cli/backends/telnet.py,sha256=1_xmP3LeWlHPCq-zL6s8F-25r4CJaLyr1GsM1_Y2ZbI,1931
-fh_tool_cli/backends/web_ajax.py,sha256=UDn6HT6N9KuiMMn_asBTEYw23ZR8jvReKPeVUSTcKPY,12685
+fh_tool_cli/backends/telnet.py,sha256=ud5q71oXbZjTS3wt1_qXvp5bRbyZBm4GD66Zo31RVTI,4865
+fh_tool_cli/backends/web_ajax.py,sha256=E4lbga-zuv_Z9TRWxylbIMpeECVimy8cGgWyAl04Geo,14750
 fh_tool_cli/commands/__init__.py,sha256=xXoXJsFkq0kRgoh3GOTDMkDQzocHfSAqEejPHDA9Jb8,54
-fh_tool_cli/commands/web.py,sha256=WsB5pb8nOkeDmkPfJjOXN9ieDUbgsPiHc5a4q93WeDw,36116
-fh_tool_cli-0.2.2.dist-info/METADATA,sha256=OxyucnsJRjaoyKSFzn2pRW9F0w-mVlJ-1BhwEw7H6Io,12395
-fh_tool_cli-0.2.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-fh_tool_cli-0.2.2.dist-info/entry_points.txt,sha256=7zkyLkN5pemLvfLk5EucJvB4dGI6pJcn0z32ghziSjQ,84
-fh_tool_cli-0.2.2.dist-info/top_level.txt,sha256=g3brii9lgqfPHXzj88IoqKtAxbtCfFOaYfx1Gk1M1j8,12
-fh_tool_cli-0.2.2.dist-info/RECORD,,
+fh_tool_cli/commands/web.py,sha256=ta1F9csqY4a7Ja3QR5oLtlPTSpWoyEc3SGyCFymzDO8,37413
+fh_tool_cli-0.2.3.dist-info/METADATA,sha256=iYMGjyOVNpzDwmvDsvnaKTp50r7O0BvqIUrE-YNQUlI,13849
+fh_tool_cli-0.2.3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+fh_tool_cli-0.2.3.dist-info/entry_points.txt,sha256=7zkyLkN5pemLvfLk5EucJvB4dGI6pJcn0z32ghziSjQ,84
+fh_tool_cli-0.2.3.dist-info/top_level.txt,sha256=g3brii9lgqfPHXzj88IoqKtAxbtCfFOaYfx1Gk1M1j8,12
+fh_tool_cli-0.2.3.dist-info/RECORD,,