cfquant 0.2.59__tar.gz → 0.2.61__tar.gz

{cfquant-0.2.59 → cfquant-0.2.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.59
+Version: 0.2.61
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8
@@ -15,7 +15,7 @@ Requires-Dist: pytz
 Requires-Dist: tabulate
 Requires-Dist: pandas-market-calendars
 Requires-Dist: importlib-resources>=5
-Requires-Dist: frida<18,>=17.0; sys_platform == "win32"
+Requires-Dist: frida==17.16.4; sys_platform == "win32"
 Requires-Dist: pywin32>=306; sys_platform == "win32"
 Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == "dev"

{cfquant-0.2.59 → cfquant-0.2.61}/cfquant/_editable_install.py

@@ -10,9 +10,9 @@ import tempfile
 from pathlib import Path
 
 if __package__:
-    from .qmt_dependencies import report_startup_dependencies
+    from .qmt_dependencies import FRIDA_REQUIREMENT, FRIDA_VERSION, report_startup_dependencies
 else:
-    from qmt_dependencies import report_startup_dependencies
+    from qmt_dependencies import FRIDA_REQUIREMENT, FRIDA_VERSION, report_startup_dependencies
 
 
 PACKAGE_NAME = "cfquant"
@@ -517,6 +517,32 @@ def installed_package_version(python_exe=None):
     return completed.stdout.strip() if completed.returncode == 0 else ""
 
 
+def reconcile_startup_frida(project_root, python_exe):
+    """Repair version drift even when cfquant's own version did not change.
+
+    This launcher runs before Web/Frida loads. Failed optional repair must not
+    prevent manual QMT use; the native worker also checks before importing.
+    """
+    report = report_startup_dependencies(python_exe) or {}
+    if os.environ.get("CFQUANT_QMT_AUTOMATION", "1").lower() in ("0", "false", "off"):
+        return
+    if not report.get("supported") or not report.get("packages"):
+        return
+    if report["packages"].get("frida") == FRIDA_VERSION:
+        return
+    print("[INFO] Installing QMT compatibility dependency: %s" % FRIDA_REQUIREMENT)
+    command = [python_exe, "-m", "pip", "install", "--disable-pip-version-check", "--no-input",
+               "--timeout", "15", "--retries", "1"] + pip_index_args() + [FRIDA_REQUIREMENT]
+    try:
+        completed = subprocess.run(command, cwd=str(project_root), env=pip_environment(),
+                                   timeout=120, **_hidden_subprocess_kwargs())
+        if completed.returncode:
+            raise RuntimeError("pip exit code %s" % completed.returncode)
+    except (OSError, RuntimeError, subprocess.TimeoutExpired) as error:
+        print("[WARN] Frida compatibility repair failed: %s. Web can continue; use manual QMT login." % error)
+    report_startup_dependencies(python_exe)
+
+
 def ensure_cfquant_installed(project_root, python_exe=None):
     project_root = Path(project_root).resolve()
     if not (project_root / "pyproject.toml").is_file():
@@ -546,7 +572,7 @@ def ensure_cfquant_installed(project_root, python_exe=None):
     print("cfquant installed=%s project=%s" % (installed or "missing", expected))
     if installed == expected:
         print("Package versions match; skip installation.")
-        report_startup_dependencies(python_exe)
+        reconcile_startup_frida(project_root, python_exe)
         return 0
 
     command = editable_install_args(project_root, python_exe)
@@ -570,7 +596,7 @@ def ensure_cfquant_installed(project_root, python_exe=None):
         print("[ERROR] Installed cfquant version does not match the project after installation.", file=sys.stderr)
         return 1
     print("%s package is installed." % PACKAGE_NAME)
-    report_startup_dependencies(python_exe)
+    reconcile_startup_frida(project_root, python_exe)
     return 0
 
 

{cfquant-0.2.59 → cfquant-0.2.61}/cfquant/normal_bridge.py

@@ -194,7 +194,7 @@ class NormalQmtBridge(TxTradeBridge):
         if action == "cfquant.status":
             self._send_response(msg, self._status())
             return
-        if action == "cfquant.strategy.control":
+        if action in ("cfquant.strategy.control", "cfquant.account_subscription_status"):
             try:
                 self._send_response(msg, self._dispatch(action, msg.get("params") or {}, msg))
             except Exception as error:

{cfquant-0.2.59 → cfquant-0.2.61}/cfquant/pipe_bridge.py

@@ -48,8 +48,16 @@ class PipeNormalQmtBridge(NormalQmtBridge):
         self.pipe_name = pipe_name or DEFAULT_PIPE_NAME
         self.request_channels = list(request_channels or [request_channel])
         self.connect_timeout_ms = int(connect_timeout_ms)
+        self._pipe_lock = threading.RLock()
+        self._pipe_closed = False
 
     def start(self):
+        with self._pipe_lock:
+            if self._pipe_closed:
+                raise RuntimeError("pipe bridge is closed")
+            return self._start_transport()
+
+    def _start_transport(self):
         runtime = self.globals_dict.get("_managed_runtime")
         if runtime is not None:
             runtime.attach_bridge(self)
@@ -80,23 +88,31 @@ class PipeNormalQmtBridge(NormalQmtBridge):
         self._publish_runtime_report("start")
         return self
 
+    def stop_transport(self):
+        # This phase must not wait for QMT native work or dispatch_lock.
+        with self._pipe_lock:
+            self._pipe_closed = True
+            self.running = False
+            tx, self.tx = self.tx, None
+        event = getattr(self, "worker_event", None)
+        if event is not None:
+            event.set()
+        if tx is not None:
+            tx.close()
+        deadline = time.monotonic() + 0.5
+        for worker in (getattr(self, "recv_thread", None), getattr(self, "worker_thread", None)):
+            if worker is not None and worker is not threading.current_thread() and worker.is_alive():
+                worker.join(max(0.0, deadline - time.monotonic()))
+
     def close(self):
+        self.stop_transport()
         self._flush_pending_order_errors(force=True)
-        self.running = False
-        self.worker_event.set()
         self._close_quote_subscriptions()
         if self.context is not None and self.schedule_key:
             try:
                 self.context.cancel_schedule_run(self.schedule_key)
             except Exception:
                 pass
-        tx = self.tx
-        self.tx = None
-        if tx is not None:
-            try:
-                tx.close()
-            except Exception:
-                pass
         self._log("pipe normal bridge stopped")
 
     def _status_extra(self):
@@ -138,8 +154,16 @@ class PipeTradeBridge(TxTradeBridge):
         )
         self.pipe_name = pipe_name or DEFAULT_PIPE_NAME
         self.connect_timeout_ms = int(connect_timeout_ms)
+        self._pipe_lock = threading.RLock()
+        self._pipe_closed = False
 
     def start(self):
+        with self._pipe_lock:
+            if self._pipe_closed:
+                raise RuntimeError("pipe bridge is closed")
+            return self._start_transport()
+
+    def _start_transport(self):
         runtime = self.globals_dict.get("_managed_runtime")
         if runtime is not None:
             runtime.attach_bridge(self)
@@ -166,15 +190,11 @@ class PipeTradeBridge(TxTradeBridge):
         self._publish_runtime_report("start")
         return self
 
+    def stop_transport(self):
+        PipeNormalQmtBridge.stop_transport(self)
+
     def close(self):
-        self.running = False
-        tx = self.tx
-        self.tx = None
-        if tx is not None:
-            try:
-                tx.close()
-            except Exception:
-                pass
+        self.stop_transport()
         self._log("pipe trade bridge stopped")
 
     def poll(self, max_messages=100, timeout=0):

{cfquant-0.2.59 → cfquant-0.2.61}/cfquant/pipe_transport.py

@@ -254,12 +254,14 @@ class NamedPipeConnection(object):
                 offset += written.value
 
 
-def connect_pipe(pipe_name=None, timeout_ms=3000):
+def connect_pipe(pipe_name=None, timeout_ms=3000, stop_event=None):
     pipe_name = normalize_pipe_name(pipe_name)
     k32 = kernel32()
-    deadline = time.time() + max(float(timeout_ms), 1.0) / 1000.0
+    deadline = time.monotonic() + max(float(timeout_ms), 1.0) / 1000.0
     last_error = None
     while True:
+        if stop_event is not None and stop_event.is_set():
+            raise ConnectionAbortedError("named pipe connection cancelled")
         handle = k32.dll.CreateFileW(
             pipe_name,
             GENERIC_READ | GENERIC_WRITE,
@@ -270,16 +272,23 @@ def connect_pipe(pipe_name=None, timeout_ms=3000):
             None,
         )
         if not k32.invalid_handle(handle):
-            return NamedPipeConnection(handle, pipe_name, owner_server_side=False)
+            conn = NamedPipeConnection(handle, pipe_name, owner_server_side=False)
+            if stop_event is not None and stop_event.is_set():
+                conn.close()
+                raise ConnectionAbortedError("named pipe connection cancelled")
+            return conn
         last_error = k32.last_error()
         if last_error == ERROR_PIPE_BUSY:
-            wait_ms = min(250, max(1, int((deadline - time.time()) * 1000)))
+            wait_ms = min(50 if stop_event is not None else 250,
+                          max(1, int((deadline - time.monotonic()) * 1000)))
             k32.dll.WaitNamedPipeW(pipe_name, wait_ms)
-        elif last_error in (ERROR_FILE_NOT_FOUND, ERROR_ACCESS_DENIED):
-            time.sleep(0.05)
+        elif stop_event is not None:
+            stop_event.wait(0.05)
         else:
             time.sleep(0.05)
-        if time.time() >= deadline:
+        if stop_event is not None and stop_event.is_set():
+            raise ConnectionAbortedError("named pipe connection cancelled")
+        if time.monotonic() >= deadline:
             raise OSError(last_error or 0, "connect named pipe timeout pipe=%s winerror=%s" % (pipe_name, last_error))
 
 
@@ -366,21 +375,27 @@ class PipeTxClient(object):
         self._sender = None
         self._sender_conn = None
         self._stop_event = threading.Event()
+        self._closed = False
+        self._connecting_conns = set()
         self.send_max_bytes = int(os.environ.get("CFQUANT_PIPE_SEND_MAX_BYTES", 128 * 1024 * 1024))
         self.send_timeout = float(os.environ.get("CFQUANT_PIPE_SEND_TIMEOUT", "15"))
 
     def start(self):
-        if self.running:
-            return self
-        self.running = True
-        self._stop_event.clear()
-        self.thread = threading.Thread(target=self._connect_loop)
-        self.thread.daemon = True
-        self.thread.start()
-        if self.heartbeat_interval > 0 or self.send_timeout > 0:
-            self.heartbeat_thread = threading.Thread(target=self._heartbeat_loop)
-            self.heartbeat_thread.daemon = True
-            self.heartbeat_thread.start()
+        with self.conn_lock:
+            # A strategy restart creates a new client. Reusing this stop event
+            # could reactivate workers still exiting from the previous run.
+            if self._closed:
+                raise RuntimeError("pipe tx client is closed")
+            if self.running:
+                return self
+            self.running = True
+            self.thread = threading.Thread(target=self._connect_loop, name="cfquant-pipe-connect")
+            self.thread.daemon = True
+            self.thread.start()
+            if self.heartbeat_interval > 0 or self.send_timeout > 0:
+                self.heartbeat_thread = threading.Thread(target=self._heartbeat_loop, name="cfquant-pipe-heartbeat")
+                self.heartbeat_thread.daemon = True
+                self.heartbeat_thread.start()
         return self
 
     def start_tx(self):
@@ -406,6 +421,8 @@ class PipeTxClient(object):
             if not isinstance(payload, str):
                 raise TypeError("pipe publish payload must be an encoded string")
             with self.conn_lock:
+                if self._closed:
+                    return {"code": -1, "msg": "pipe tx client is closed"}
                 if (self.tx_conn, self.connection_generation) != (conn, generation):
                     raise RuntimeError("pipe connection changed before send")
                 if self._sender is None or self._sender_conn is not conn:
@@ -430,25 +447,59 @@ class PipeTxClient(object):
             return {"code": -1, "msg": str(e)}
 
     def close(self):
-        self.running = False
-        self._stop_event.set()
+        with self.conn_lock:
+            self._closed = True
+            self.running = False
+            self._stop_event.set()
+            connecting = tuple(self._connecting_conns)
+            self._connecting_conns.clear()
+            sender = self._sender
+            workers = (self.thread, self.heartbeat_thread)
+        # Interrupt ReadFile/WriteFile, including either hello handshake,
+        # before joining. Native cleanup and joins must not hold conn_lock.
+        self._drop_pair(None, reason="pipe tx client closed", conns=connecting)
+        # A concurrent submit may have started the sender just before it was
+        # closed. Read its thread only after close prevents further submits.
+        workers += (getattr(sender, "_thread", None),)
         try:
             self.Q.put_nowait(None)
-        except Exception:
+        except queue.Full:
             pass
-        self._drop_pair(None, reason="pipe tx client closed", conns=self._get_conns())
+        deadline = time.monotonic() + 1.0
+        for worker in workers:
+            if worker is not None and worker is not threading.current_thread() and worker.is_alive():
+                worker.join(max(0.0, deadline - time.monotonic()))
+
+    def _open_connection(self, role):
+        conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms,
+                            stop_event=self._stop_event)
+        try:
+            with self.conn_lock:
+                if self._closed:
+                    raise ConnectionAbortedError("pipe tx client is closed")
+                self._connecting_conns.add(conn)
+            conn.write_frame(dumps_pipe_message(self._pipe_envelope("hello", role)))
+            if self._stop_event.is_set():
+                raise ConnectionAbortedError("pipe tx client is closed")
+            return conn
+        except BaseException:
+            with self.conn_lock:
+                self._connecting_conns.discard(conn)
+            self._close_conns((conn,))
+            raise
 
     def _connect_loop(self):
-        while self.running:
+        while self.running and not self._stop_event.is_set():
             rx_conn = None
             tx_conn = None
             generation = None
             try:
-                rx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
-                rx_conn.write_frame(dumps_pipe_message(self._pipe_envelope("hello", "qmt_rx")))
-                tx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
-                tx_conn.write_frame(dumps_pipe_message(self._pipe_envelope("hello", "qmt_tx")))
+                rx_conn = self._open_connection("qmt_rx")
+                tx_conn = self._open_connection("qmt_tx")
                 with self.conn_lock:
+                    if self._closed:
+                        raise ConnectionAbortedError("pipe tx client is closed")
+                    self._connecting_conns.difference_update((rx_conn, tx_conn))
                     self.connection_generation += 1
                     generation = self.connection_generation
                     self.rx_conn = rx_conn
@@ -461,29 +512,44 @@ class PipeTxClient(object):
                 )
                 self._read_loop(rx_conn, generation)
             except Exception as e:
-                self.last_error = str(e)
-                if self.running:
-                    self._log("pipe connect/read failed: %s" % e)
+                with self.conn_lock:
+                    if self.running and not self._closed:
+                        self.last_error = str(e)
+                        self._log("pipe connect/read failed: %s" % e)
             finally:
+                with self.conn_lock:
+                    self._connecting_conns.difference_update((rx_conn, tx_conn))
                 if generation is None:
                     self._close_conns((rx_conn, tx_conn))
                 else:
                     self._drop_pair(generation, conns=(rx_conn, tx_conn))
-            if self.running:
-                time.sleep(self.reconnect_interval)
+            if self._stop_event.wait(max(0.0, self.reconnect_interval)):
+                break
 
     def _read_loop(self, conn, generation):
-        while self.running and self._get_rx_state() == (conn, generation):
+        while self.running and not self._stop_event.is_set() and self._get_rx_state() == (conn, generation):
             raw = conn.read_frame()
             if raw is None:
                 break
             envelope = loads_pipe_message(raw)
             if envelope:
                 payload = envelope.get("payload")
-                if payload:
-                    self.Q.put(payload)
+                if payload and not self._queue_received(payload):
+                    return
                 continue
-            self.Q.put(raw)
+            if not self._queue_received(raw):
+                return
+
+    def _queue_received(self, payload):
+        # A stopped bridge no longer drains Q. Never leave the reader blocked
+        # forever in put() when its bounded queue is full at shutdown.
+        while self.running and not self._stop_event.is_set():
+            try:
+                self.Q.put(payload, timeout=0.1)
+                return True
+            except queue.Full:
+                pass
+        return False
 
     def _get_rx_conn(self):
         with self.conn_lock:

{cfquant-0.2.59 → cfquant-0.2.61}/cfquant/protocol.py

@@ -154,7 +154,8 @@ def is_readonly_request(action):
     # Only known query families. Downloads, subscriptions and all writes retain
     # their existing execution semantics, including on an ambiguous timeout.
     return (str(action).startswith(("xtdata.get_", "xttrader.query_"))
-            or action in ("cfquant.ping", "cfquant.status", "cfquant.query_info"))
+            or action in ("cfquant.ping", "cfquant.status", "cfquant.query_info",
+                          "cfquant.account_subscription_status"))
 
 
 def request_expired(msg, now=None):

cfquant-0.2.61/cfquant/qmt_binding_defaults.py

@@ -0,0 +1,54 @@
+"""One-time migration of QMT automation preferences, using saved version evidence."""
+import copy
+import re
+
+
+AUTOMATION_DEFAULTS_VERSION = "0.2.59"
+MIGRATION_KEY = "qmt_automation_defaults_migration"
+
+
+def is_pre_automation_defaults_version(value):
+    """Schema numbers, missing values and unrecognized versions are not evidence."""
+    match = re.fullmatch(r"v?(\d+)\.(\d+)\.(\d+)(?:(a|b|rc)\d+)?(?:\.post\d+)?(?:\+[-\w.]+)?", str(value or "").strip())
+    if not match:
+        return False
+    version = tuple(int(match.group(i)) for i in (1, 2, 3))
+    return version < (0, 2, 59) or (version == (0, 2, 59) and bool(match.group(4)))
+
+
+def migrate_qmt_automation_defaults(raw):
+    """Return a copy only when a known old configuration needs migration.
+
+    The running/installed version and QMT's version do not date user preferences.
+    They must never be used as substitutes for the saved configuration version.
+    """
+    if not isinstance(raw, dict) or raw.get(MIGRATION_KEY):
+        return raw, 0
+    source_version = raw.get("saved_core_version", raw.get("core_version"))
+    if not is_pre_automation_defaults_version(source_version):
+        return raw, 0
+    result = copy.deepcopy(raw)
+    changed = 0
+    for collection in ("account_configs", "account_pairs"):
+        rows = result.get(collection) or {}
+        rows = rows.values() if isinstance(rows, dict) else rows if isinstance(rows, list) else []
+        for row in rows:
+            if not isinstance(row, dict) or not row.get("account_id"):
+                continue
+            login = row.get("qmt_auto_login")
+            login = dict(login) if isinstance(login, dict) else {}
+            login.update(enabled=True, auto_update=True)
+            # Preserve custom schedules and explicit empty schedules. Only absent
+            # schedules receive the same default as a new binding.
+            if not any(key in login for key in ("restart_times", "restartTimes", "restart_time", "restartTime")):
+                login["restart_times"] = ["09:00"]
+            row["qmt_auto_login"] = login
+            if collection == "account_configs":
+                strategy = row.get("qmt_strategy")
+                strategy = dict(strategy) if isinstance(strategy, dict) else {}
+                strategy.update(enabled=True, autorun=True)
+                row["qmt_strategy"] = strategy
+                changed += 1
+    result[MIGRATION_KEY] = {"version": AUTOMATION_DEFAULTS_VERSION, "source_version": str(source_version),
+                             "bindings": changed}
+    return result, changed

{cfquant-0.2.59 → cfquant-0.2.61}/cfquant/qmt_component_login.py

@@ -11,6 +11,8 @@ from pathlib import Path
 import sys
 import time
 
+from .qmt_native_worker import IsolatedLoginBackend, QmtAutomationCancelled, verify_environment_isolated
+
 
 class QmtNotReady(RuntimeError):
     pass
@@ -22,6 +24,11 @@ class QmtProcessExited(RuntimeError):
 
 def verify_environment(directory):
     """Validate dependencies and native ABI before stopping a running terminal."""
+    verify_environment_isolated(directory)
+
+
+def _verify_environment_native(directory):
+    """Only invoked inside the native worker or the standalone login CLI."""
     try:
         from .qmt_dependencies import LOGIN_MODULES, import_login_module
     except ImportError:
@@ -163,7 +170,7 @@ class QtLoginBackend:
         self.pid = matches[0].pid
         if expected_pid is not None and self.pid != expected_pid:
             raise RuntimeError("QMT process changed; stopping this login attempt")
-        verify_environment(directory)
+        _verify_environment_native(directory)
         self.mutex = win32event.CreateMutex(None, False, "Local\\CFQuantQmtComponentLogin_" + str(self.pid))
         acquired = win32event.WaitForSingleObject(self.mutex, 0)
         if acquired not in (0, 0x80):
@@ -367,8 +374,11 @@ def login_running_qmt(directory, login_account="", password_provider=lambda: "",
         if should_cancel():
             return {"outcome": "cancelled", "login_succeeded": False, "attempts": []}
         try:
-            backend = QtLoginBackend(Path(directory), timeout, expected_pid=expected_pid)
+            backend = IsolatedLoginBackend(Path(directory), timeout, expected_pid=expected_pid,
+                                           should_cancel=should_cancel)
             break
+        except QmtAutomationCancelled:
+            return {"outcome": "cancelled", "login_succeeded": False, "attempts": []}
         except QmtProcessExited:
             return {"outcome": "process_exited", "login_succeeded": False, "attempts": []}
         except QmtNotReady:
@@ -380,6 +390,8 @@ def login_running_qmt(directory, login_account="", password_provider=lambda: "",
         backend.should_cancel = should_cancel
         return auto_login(backend, password_provider, retry_not_ready=True, login_account=login_account,
                           should_cancel=should_cancel, on_wait=on_wait)
+    except QmtAutomationCancelled:
+        return {"outcome": "cancelled", "login_succeeded": False, "attempts": []}
     except QmtProcessExited:
         return {"outcome": "process_exited", "login_succeeded": False, "attempts": []}
     finally:

{cfquant-0.2.59 → cfquant-0.2.61}/cfquant/qmt_dependencies.py

@@ -1,6 +1,7 @@
 """Read-only checks and repair instructions for optional QMT login components."""
 import copy
 import importlib
+import importlib.metadata
 import json
 import os
 import subprocess
@@ -10,6 +11,10 @@ import time
 
 
 LOGIN_MODULES = ("frida", "win32api", "win32crypt", "win32event", "win32gui", "win32process")
+# Verified QMT baseline. 17.25 introduced a Windows mapper that can abort the
+# host on older ntdll builds; do not widen this without Windows/QMT validation.
+FRIDA_VERSION = "17.16.4"
+FRIDA_REQUIREMENT = "frida==" + FRIDA_VERSION
 _LOCK = threading.Lock()
 _CACHE = {}
 _PROBE_CODE = r'''
@@ -17,6 +22,8 @@ import importlib, importlib.metadata, json, os, pathlib, sys
 checks = []
 for name in MODULES:
     try:
+        if name == 'frida' and importlib.metadata.version('frida') != FRIDA_VERSION:
+            raise RuntimeError('Unsupported Frida version; install frida==' + FRIDA_VERSION)
         module = importlib.import_module(name)
         checks.append(dict(name=name, ok=True, path=getattr(module, '__file__', '')))
     except Exception as error:
@@ -46,6 +53,16 @@ def _ps_quote(value):
 
 
 def _finish_report(report):
+    if report.get("supported"):
+        version = (report.get("packages") or {}).get("frida")
+        if version and version != FRIDA_VERSION:
+            checks = report.setdefault("checks", [])
+            check = next((item for item in checks if item["name"] == "frida"), None)
+            if check is None:
+                check = {"name": "frida"}
+                checks.append(check)
+            check.update(ok=False, error="Frida %s 未通过本项目兼容性验证，请安装 %s" % (version, FRIDA_REQUIREMENT))
+        report["frida_requirement"] = FRIDA_REQUIREMENT
     report["checked_at"] = time.time()
     report["ok"] = bool(report.get("supported") and not report.get("error")
                         and all(item["ok"] for item in report.get("checks", [])))
@@ -73,8 +90,10 @@ def _finish_report(report):
                 if environment == "python":
                     commands.append(python + " -m pywin32_postinstall -install")
         if any(item["name"] == "frida" for item in failed):
-            commands.append(python + " -m pip install --no-cache-dir --upgrade --force-reinstall 'frida>=17.0,<18'")
-        commands.append(python + " -c " + _ps_quote("import " + ", ".join(LOGIN_MODULES) + "; print('QMT login components OK')"))
+            commands.append(python + " -m pip install --no-cache-dir --force-reinstall '" + FRIDA_REQUIREMENT + "'")
+        commands.append(python + " -c " + _ps_quote(
+            "from cfquant.qmt_dependencies import report_startup_dependencies; "
+            "r=report_startup_dependencies(); raise SystemExit(0 if r['ok'] else 1)"))
     report["repair_commands"] = commands
     if environment == "conda":
         report["repair_note"] = (
@@ -111,7 +130,7 @@ def check_login_dependencies(python_exe=None, refresh=False, timeout=15):
             if os.name == "nt":
                 run_kwargs["creationflags"] = getattr(subprocess, "CREATE_NO_WINDOW", 0)
             completed = subprocess.run(
-                [executable, "-c", "MODULES = %r\n" % (LOGIN_MODULES,) + _PROBE_CODE],
+                [executable, "-c", "MODULES = %r\nFRIDA_VERSION = %r\n" % (LOGIN_MODULES, FRIDA_VERSION) + _PROBE_CODE],
                 stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8",
                 errors="replace", timeout=timeout,
                 **run_kwargs,
@@ -130,8 +149,21 @@ class QmtDependencyError(RuntimeError):
     pass
 
 
+def require_compatible_frida():
+    try:
+        version = importlib.metadata.version("frida")
+    except importlib.metadata.PackageNotFoundError:
+        version = "未安装"
+    if version != FRIDA_VERSION:
+        raise QmtDependencyError(
+            "Frida %s 未通过本项目兼容性验证，已跳过 QMT 自动操作。"
+            "请在当前 Python 环境安装 %s；手动登录及行情交易接口仍可使用。" % (version, FRIDA_REQUIREMENT))
+
+
 def import_login_module(name):
     """Keep in-process import errors actionable, including stale loaded DLLs."""
+    if name == "frida":
+        require_compatible_frida()
     try:
         return importlib.import_module(name)
     except (ImportError, OSError) as error: