cfquant 0.2.61__tar.gz → 0.2.62__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.61
+Version: 0.2.62
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8

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

@@ -27,7 +27,7 @@ def verify_environment(directory):
     verify_environment_isolated(directory)
 
 
-def _verify_environment_native(directory):
+def _verify_environment_native(directory, *, strategy=False):
     """Only invoked inside the native worker or the standalone login CLI."""
     try:
         from .qmt_dependencies import LOGIN_MODULES, import_login_module
@@ -38,14 +38,17 @@ def _verify_environment_native(directory):
     directory = Path(directory)
     for module in ("Qt5Core.dll", "Qt5Widgets.dll"):
         version = win32api.GetFileVersionInfo(str(directory / module), "\\")
-        if (version["FileVersionMS"], version["FileVersionLS"]) != ((5 << 16) | 6, 2 << 16):
+        if strategy:
+            if version["FileVersionMS"] >> 16 != 5:
+                raise RuntimeError("QMT 策略检测需要兼容的 Qt 5 接口，当前组件 ABI 不受支持")
+        elif (version["FileVersionMS"], version["FileVersionLS"]) != ((5 << 16) | 6, 2 << 16):
             raise RuntimeError("QMT 组件自动登录当前仅支持 Qt 5.6.2，请先适配此客户端版本")
     with (directory / "XtItClient.exe").open("rb") as stream:
         stream.seek(0x3C)
         offset = int.from_bytes(stream.read(4), "little")
         stream.seek(offset + 4)
         if int.from_bytes(stream.read(2), "little") != 0x8664:
-            raise RuntimeError("QMT 组件自动登录需要 64 位客户端")
+            raise RuntimeError("QMT 原生组件操作需要 64 位客户端")
 
 
 def auto_login(backend, password_provider, *, retry_not_ready=False, login_account=None,
@@ -132,7 +135,7 @@ def select_binding(config_path, name):
 
 
 class QtLoginBackend:
-    def __init__(self, directory, timeout=40, expected_pid=None, *, agent_extension=""):
+    def __init__(self, directory, timeout=40, expected_pid=None, *, agent_extension="", strategy=False):
         try:
             from .qmt_dependencies import import_login_module
         except ImportError:
@@ -170,7 +173,10 @@ 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_native(directory)
+        if strategy:
+            _verify_environment_native(directory, strategy=True)
+        else:
+            _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):
@@ -179,13 +185,16 @@ class QtLoginBackend:
             raise RuntimeError("Another component login is already running for this QMT")
         try:
             self.session = frida.attach(self.pid)
-            readiness = self.session.create_script("rpc.exports.ready = () => ['Qt5Core.dll', 'Qt5Widgets.dll', 'LoginDialog.dll'].every(n => Process.findModuleByName(n) !== null);")
+            modules = ["Qt5Core.dll", "Qt5Widgets.dll"]
+            if not strategy:
+                modules.append("LoginDialog.dll")
+            readiness = self.session.create_script("rpc.exports.ready = () => %s.every(n => Process.findModuleByName(n) !== null);" % json.dumps(modules))
             readiness.load()
             ready = readiness.exports_sync.ready()
             readiness.unload()
             if not ready:
                 raise QmtNotReady("QMT login modules are still loading")
-            source = Path(__file__).with_name("qmt_component_agent.js").read_text(encoding="utf-8")
+            source = "" if strategy else Path(__file__).with_name("qmt_component_agent.js").read_text(encoding="utf-8")
             script = self.session.create_script(source + "\n" + agent_extension)
             script.on("message", lambda message, data: self.messages.append("agent_error") if message.get("type") == "error" else None)
             script.load()

cfquant-0.2.62/cfquant/qmt_strategy_agent.js

@@ -0,0 +1,239 @@
+'use strict';
+
+// A scope also permits an older Python host to append this agent to its login
+// agent while the project is being upgraded.
+(() => {
+// Resolve query, start and notice APIs independently of the login agent.
+const missing = {gui: [], query: [], start: [], notice: [], dismiss: []};
+function native(group, moduleName, name, result, args) {
+  const module = Process.findModuleByName(moduleName);
+  const address = module && module.findExportByName(name);
+  if (!address) {
+    missing[group].push(moduleName + ':' + name);
+    return null;
+  }
+  return new NativeFunction(address, result, args);
+}
+const findWidget = native('gui', 'Qt5Widgets.dll', '?find@QWidget@@SAPEAV1@_K@Z', 'pointer', ['uint64']);
+const inherits = native('gui', 'Qt5Core.dll', '?inherits@QObject@@QEBA_NPEBD@Z', 'bool', ['pointer', 'pointer']);
+const getThread = native('gui', 'user32.dll', 'GetWindowThreadProcessId', 'uint32', ['pointer', 'pointer']);
+const postMessage = native('gui', 'user32.dll', 'PostMessageW', 'bool', ['pointer', 'uint32', 'pointer', 'pointer']);
+const dispatchModule = Process.findModuleByName('user32.dll');
+const dispatchAddress = dispatchModule && dispatchModule.findExportByName('DispatchMessageW');
+if (!dispatchAddress) missing.gui.push('user32.dll:DispatchMessageW');
+if (Process.arch !== 'x64' || Process.pointerSize !== 8) missing.gui.push('x64 ABI');
+const stringCtor = native('query', 'Qt5Core.dll', '??0QString@@QEAA@PEBVQChar@@H@Z', 'pointer', ['pointer', 'pointer', 'int']);
+const stringDtor = native('query', 'Qt5Core.dll', '??1QString@@QEAA@XZ', 'void', ['pointer']);
+const stringSize = native('query', 'Qt5Core.dll', '?size@QString@@QEBAHXZ', 'int', ['pointer']);
+const stringData = native('query', 'Qt5Core.dll', '?utf16@QString@@QEBAPEBGXZ', 'pointer', ['pointer']);
+const strategyManager = native('query', 'Formula.dll', '?instance@?$CSingletonT@VCStrategyTradeManager@TC@@@utils@@SAPEAVCStrategyTradeManager@TC@@XZ', 'pointer', []);
+const strategySave = native('query', 'Formula.dll', '?saveSettings@CStrategyTradeManager@TC@@QEAAXAEAVQDomElement@@AEAVQDomDocument@@@Z', 'void', ['pointer', 'pointer', 'pointer']);
+// isStrategyRun takes a request identifier; isFomrulaRun takes a formula name.
+const strategyRunning = native('query', 'Formula.dll', '?isFomrulaRun@CStrategyTradeManager@TC@@QEAA_NAEBVQString@@@Z', 'bool', ['pointer', 'pointer']);
+const strategyWhitelistReady = native('start', 'Formula.dll', '?isConnWhiteListReady@CStrategyTradeManager@TC@@QEBA_NXZ', 'bool', ['pointer']);
+const strategyRun = native('start', 'Formula.dll', '?runStrategy@CStrategyTradeManager@TC@@QEAAXHAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z', 'void', ['pointer', 'int', 'pointer']);
+const strategyDocCtor = native('query', 'Qt5Xml.dll', '??0QDomDocument@@QEAA@XZ', 'pointer', ['pointer']);
+const strategyDocDtor = native('query', 'Qt5Xml.dll', '??1QDomDocument@@QEAA@XZ', 'void', ['pointer']);
+const strategyElemDtor = native('query', 'Qt5Xml.dll', '??1QDomElement@@QEAA@XZ', 'void', ['pointer']);
+const strategyCreateElem = native('query', 'Qt5Xml.dll', '?createElement@QDomDocument@@QEAA?AVQDomElement@@AEBVQString@@@Z', 'pointer', ['pointer', 'pointer', 'pointer']);
+const strategyFirst = native('query', 'Qt5Xml.dll', '?firstChildElement@QDomNode@@QEBA?AVQDomElement@@AEBVQString@@@Z', 'pointer', ['pointer', 'pointer', 'pointer']);
+const strategyNext = native('query', 'Qt5Xml.dll', '?nextSiblingElement@QDomNode@@QEBA?AVQDomElement@@AEBVQString@@@Z', 'pointer', ['pointer', 'pointer', 'pointer']);
+const strategyNull = native('query', 'Qt5Xml.dll', '?isNull@QDomNode@@QEBA_NXZ', 'bool', ['pointer']);
+const strategyAttr = native('query', 'Qt5Xml.dll', '?attribute@QDomElement@@QEBA?AVQString@@AEBV2@0@Z', 'pointer', ['pointer', 'pointer', 'pointer', 'pointer']);
+const isVisible = native('notice', 'Qt5Widgets.dll', '?isVisible@QWidget@@QEBA_NXZ', 'bool', ['pointer']);
+const children = native('notice', 'Qt5Core.dll', '?children@QObject@@QEBAAEBV?$QList@PEAVQObject@@@@XZ', 'pointer', ['pointer']);
+const noticeText = native('notice', 'BaseWidget.dll', '?getText@CSimpleTextWidget@XP@@QEBA?AVQString@@XZ', 'pointer', ['pointer', 'pointer']);
+const closeNotice = native('dismiss', 'Dialog.dll', '?closeMessage@CGlobalMessageDialog@XP@@SAXXZ', 'void', []);
+
+function capabilities() {
+  const query = missing.gui.concat(missing.query);
+  const start = query.concat(missing.start);
+  const notice = query.concat(missing.notice);
+  const dismiss = notice.concat(missing.dismiss);
+  return {can_query: !query.length, can_start: !start.length,
+    can_read_notices: !notice.length, can_dismiss_notices: !dismiss.length,
+    missing_query: query, missing_start: start, missing_notice: notice, missing_dismiss: dismiss};
+}
+const typeNames = new Map();
+function hasType(object, name) {
+  if (!typeNames.has(name)) typeNames.set(name, Memory.allocUtf8String(name));
+  return inherits(object, typeNames.get(name));
+}
+function getRoot(hwnd) {
+  const root = findWidget(uint64(hwnd));
+  if (root.isNull()) throw new Error('No Qt widget for target window');
+  return root;
+}
+let pending = null;
+function onGui(hwnd, operation) {
+  if (missing.gui.length) throw new Error('Missing Qt GUI interfaces: ' + missing.gui.join(', '));
+  if (pending) throw new Error('An operation is already pending');
+  const thread = getThread(ptr(hwnd), NULL);
+  if (!thread) throw new Error('Target window no longer exists');
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      if (pending && pending.resolve === resolve) {
+        pending = null;
+        reject(new Error('GUI operation timeout'));
+      }
+    }, 8000);
+    pending = {thread, operation, resolve, reject, timer};
+    if (!postMessage(ptr(hwnd), 0, NULL, NULL)) {
+      pending = null;
+      clearTimeout(timer);
+      reject(new Error('Cannot wake QMT GUI thread'));
+    }
+  });
+}
+if (!missing.gui.length) Interceptor.attach(dispatchAddress, {
+  onLeave() {
+    if (!pending || this.threadId !== pending.thread) return;
+    const job = pending;
+    pending = null;
+    clearTimeout(job.timer);
+    try { job.resolve({gui_thread: this.threadId, result: job.operation()}); }
+    catch (error) { job.reject(error); }
+  }
+});
+
+function strategyString(text, action) {
+  const value = Memory.alloc(Process.pointerSize);
+  stringCtor(value, Memory.allocUtf16String(text), text.length);
+  try { return action(value); } finally { stringDtor(value); }
+}
+
+function readString(value) {
+  const size = stringSize(value);
+  if (size < 0 || size > 65536) throw new Error('Invalid Qt string size');
+  return size ? stringData(value).readUtf16String(size) : '';
+}
+
+function strategyAttribute(element, name) {
+  return strategyString(name, key => strategyString('', empty => {
+    const value = Memory.alloc(Process.pointerSize);
+    strategyAttr(element, value, key, empty);
+    try { return readString(value); }
+    finally { stringDtor(value); }
+  }));
+}
+
+function strategySnapshot(root, checkStartup = false) {
+  const support = capabilities();
+  if (!support.can_query) throw new Error('Missing strategy query interfaces: ' + support.missing_query.join(', '));
+  if (!hasType(root, 'TC::CMainWindow')) throw new Error('QMT is not logged in');
+  const manager = strategyManager();
+  if (manager.isNull()) throw new Error('Strategy manager unavailable');
+  const doc = Memory.alloc(64), parent = Memory.alloc(64), models = [];
+  strategyDocCtor(doc);
+  try {
+    strategyString('Models', tag => strategyCreateElem(doc, parent, tag));
+    try {
+      // Serializes only into our temporary DOM; no configuration is written.
+      strategySave(manager, parent, doc);
+      strategyString('item', tag => {
+        let element = Memory.alloc(64);
+        strategyFirst(parent, element, tag);
+        try {
+          while (!strategyNull(element)) {
+            if (models.length >= 1000) throw new Error('Too many QMT models');
+            const row = {};
+            for (const key of ['id', 'name', 'account', 'm_strAccountKey', 'runMode',
+                               'startupAutorun', 'eStrategyType', 'stock', 'peroid']) {
+              row[key] = strategyAttribute(element, key);
+            }
+            row.running = Boolean(strategyString(row.name, name => strategyRunning(manager, name)));
+            models.push(row);
+            const next = Memory.alloc(64);
+            strategyNext(element, next, tag);
+            strategyElemDtor(element);
+            element = next;
+          }
+        } finally { strategyElemDtor(element); }
+      });
+    } finally { strategyElemDtor(parent); }
+  } finally { strategyDocDtor(doc); }
+  return {models, capabilities: support,
+    whitelist_ready: checkStartup && strategyWhitelistReady ? Boolean(strategyWhitelistReady(manager)) : null};
+}
+
+rpc.exports.strategycapabilities = capabilities;
+rpc.exports.status = hwnd => onGui(hwnd, () => {
+  const root = getRoot(hwnd);
+  return {is_main: hasType(root, 'TC::CMainWindow'), is_login: hasType(root, 'TC::CLoginDialog'), login_identity: null};
+});
+rpc.exports.strategystatus = hwnd => onGui(hwnd, () => strategySnapshot(getRoot(hwnd)));
+function childObjects(object) {
+  // Qt 5 x64 QList<QObject*>; never assume broker-specific widget offsets.
+  const data = children(object).readPointer();
+  const begin = data.add(8).readS32(), end = data.add(12).readS32();
+  if (begin < 0 || end < begin || end > 5000) throw new Error('Unexpected QList layout');
+  const result = [];
+  for (let index = begin; index < end; index++) result.push(data.add(16 + index * Process.pointerSize).readPointer());
+  return result;
+}
+function illegalIpNotice(hwnd) {
+  if (!capabilities().can_read_notices) return null;
+  const root = getRoot(hwnd);
+  if (!(hasType(root, 'XP::CGlobalMessageDialog') || hasType(root, 'CGlobalMessageDialog')) || !isVisible(root)) return null;
+  const queue = [root], seen = new Set(), matches = [];
+  while (queue.length) {
+    const object = queue.shift();
+    if (object.isNull() || seen.has(object.toString())) continue;
+    seen.add(object.toString());
+    if (seen.size > 512) throw new Error('Message widget tree too large');
+    if ((hasType(object, 'XP::CSimpleTextWidget') || hasType(object, 'CSimpleTextWidget')) && isVisible(object)) {
+      const value = Memory.alloc(Process.pointerSize);
+      noticeText(object, value);
+      let text;
+      try { text = readString(value); } finally { stringDtor(value); }
+      if (/^\[防外接\]\s*Python进程访问了网络地址\s*\[[^\]]+\]\s*[，,]\s*策略运行中止[！!]\s*$/.test(text)) matches.push(text);
+    }
+    queue.push(...childObjects(object));
+  }
+  return matches.length === 1 ? {hwnd, text: matches[0]} : null;
+}
+rpc.exports.illegalipnotice = hwnd => onGui(hwnd, () => illegalIpNotice(hwnd));
+rpc.exports.dismissillegalip = (mainHwnd, hwnd, text, expected) => onGui(mainHwnd, () => {
+  if (!capabilities().can_dismiss_notices) return {outcome: 'notice_close_unavailable', closed: false};
+  const models = strategySnapshot(getRoot(mainHwnd)).models;
+  for (const target of expected) {
+    const matches = models.filter(model => model.name === target.name);
+    if (matches.length !== 1 || Object.keys(target).some(key => matches[0][key] !== target[key])) {
+      throw new Error('Strategy binding changed before warning dismissal');
+    }
+  }
+  if (!expected.length) throw new Error('No bound strategy');
+  const current = illegalIpNotice(hwnd);
+  if (!current) return {outcome: 'already_hidden_or_changed', closed: false};
+  if (current.text !== text) return {outcome: 'message_changed', closed: false};
+  closeNotice();
+  const closed = !isVisible(getRoot(hwnd));
+  return {outcome: closed ? 'closed' : 'close_failed', closed};
+});
+rpc.exports.strategystart = (hwnd, expected) => onGui(hwnd, () => {
+  if (!capabilities().can_start) return {outcome: 'detection_only', requested: false};
+  // Re-read on the same GUI turn as the mutation. Cached IDs are insufficient.
+  const snapshot = strategySnapshot(getRoot(hwnd), true);
+  const matches = snapshot.models.filter(row => row.name === expected.name);
+  if (matches.length !== 1) throw new Error('No unique bound strategy');
+  const model = matches[0];
+  for (const key of ['id', 'name', 'account', 'm_strAccountKey', 'runMode',
+                     'startupAutorun', 'eStrategyType', 'stock', 'peroid']) {
+    if (typeof expected[key] !== 'string' || !expected[key] || model[key] !== expected[key]) {
+      throw new Error('Strategy binding changed: ' + key);
+    }
+  }
+  if (!/^CFQ_[A-Za-z0-9_]+$/.test(model.name) || model.startupAutorun !== '1' ||
+      model.eStrategyType !== '4' || !/^[1-9][0-9]*$/.test(model.id) || Number(model.id) > 2147483647) {
+    throw new Error('Not an eligible managed strategy');
+  }
+  if (model.running) return {outcome: 'already_running', requested: false};
+  if (!snapshot.whitelist_ready) return {outcome: 'waiting_whitelist', requested: false};
+  // Empty release-mode MSVC x64 std::string (SSO), matching the exported ABI.
+  const reason = Memory.alloc(32);
+  reason.writeByteArray(new Uint8Array(32));
+  reason.add(24).writeU64(15);
+  strategyRun(strategyManager(), Number(model.id), reason);
+  return {outcome: 'start_requested', requested: true};
+});
+})();

{cfquant-0.2.61 → cfquant-0.2.62}/cfquant/qmt_strategy_recovery.py

@@ -6,7 +6,6 @@ The command line defaults to inspection; --ensure/--watch enable recovery.
 import argparse
 import copy
 import datetime
-import hashlib
 import json
 import os
 from pathlib import Path
@@ -24,17 +23,6 @@ from .qmt_strategy_deploy import (
 )
 
 
-# Verified on Guojin simulation 2.1.33.0 / Qt 5.6.2 x64. Native ABI support is
-# deliberately explicit; another build needs its own inspection and live test.
-SUPPORTED_FORMULA_SHA256 = {
-    "673e512bab175e068cbee5fa349e33025bf564e5f57192ff3509f87dad8b8214",
-}
-NOTICE_DLL_SHA256 = {
-    "Dialog.dll": "b71c3dc77cfa830e1037ac2b7f1cc10a43aabec113a9a4c77d0fa97b34cedd67",
-    "BaseWidget.dll": "31fd0313f8b2b1f55f0d367121782ec3dc941a884d59a40cfc77ae155e2e861b",
-}
-
-
 def visible_notice_windows(pid, main_hwnd):
     if os.name != "nt" or not pid or not main_hwnd:
         return []
@@ -92,18 +80,14 @@ class UnsupportedQmt(RuntimeError):
 class QtStrategyBackend(QtLoginBackend):
     def __init__(self, root):
         directory = qmt_root(root) / "bin.x64"
-        digest = hashlib.sha256((directory / "Formula.dll").read_bytes()).hexdigest()
-        if digest not in SUPPORTED_FORMULA_SHA256:
-            raise UnsupportedQmt("QMT 策略组件版本尚未验证，未执行自动启动")
-        self.notice_supported = all(hashlib.sha256((directory / name).read_bytes()).hexdigest() == digest
-                                    for name, digest in NOTICE_DLL_SHA256.items())
         extension = Path(__file__).with_name("qmt_strategy_agent.js").read_text(encoding="utf-8")
-        super().__init__(directory, agent_extension=extension)
+        super().__init__(directory, agent_extension=extension, strategy=True)
         try:
             if not self.already_logged_in():
                 raise QmtNotReady("QMT 尚未登录，等待主界面")
-            if "strategystatus" not in self.script.list_exports_sync():
-                raise UnsupportedQmt("QMT 策略组件接口不可用")
+            self.capabilities = self.api.strategycapabilities()
+            if not self.capabilities.get("can_query"):
+                raise UnsupportedQmt("QMT 缺少策略运行检测接口: " + ", ".join(self.capabilities.get("missing_query", [])))
         except Exception:
             self.close()
             raise
@@ -115,7 +99,7 @@ class QtStrategyBackend(QtLoginBackend):
         return self.api.strategystart(str(self.main_hwnd), expected)["result"]
 
     def notices(self):
-        if not self.notice_supported:
+        if not self.capabilities.get("can_read_notices"):
             return []
         result = []
         for hwnd in visible_notice_windows(self.pid, self.main_hwnd):
@@ -186,7 +170,15 @@ class QmtStrategyRecovery:
                              event_id=(status.get("incident") or {}).get("id"), **details))
 
     def _notices(self, job, status, backend, expected):
-        for notice in backend.notices():
+        try:
+            notices = backend.notices()
+            status.pop("notice_error", None)
+        except Exception as error:
+            # An optional broker-specific message widget must not disable
+            # the independently supported strategy-state query.
+            status["notice_error"] = str(error)
+            return
+        for notice in notices:
             if expected_models(job, self.accounts_provider()) != expected or not self.job_is_current(job):
                 raise ValueError("Binding changed before warning dismissal")
             incident = status.get("incident") or {}
@@ -249,7 +241,9 @@ class QmtStrategyRecovery:
             if (status.get("pid"), status.get("generation")) != (backend.pid, job["generation"]):
                 status = {"last_checked_at": now, "next_check_at": now + self.interval,
                           "pid": backend.pid, "generation": job["generation"], "attempts": {}}
-            models = match_models(backend.snapshot(), expected)
+            snapshot = backend.snapshot()
+            models = match_models(snapshot, expected)
+            status["capabilities"] = snapshot.get("capabilities") or {}
             status["main_hwnd"] = getattr(backend, "main_hwnd", None)
             if not inspect_only:
                 self._notices(job, status, backend, expected)
@@ -271,7 +265,9 @@ class QmtStrategyRecovery:
             else:
                 status.pop("stable_since", None)
                 status["state"] = "stopped"
-                if not inspect_only:
+                if not inspect_only and status["capabilities"].get("can_start") is False:
+                    status["state"] = "detection_only"
+                elif not inspect_only:
                     attempts = dict(status.get("attempts") or {})
                     status["attempts"] = attempts
                     if any(attempts.get(target["name"], 0) >= 5 for target in stopped):
@@ -389,8 +385,11 @@ class QmtStrategyRecoveryScheduler:
                         "backoff": "托管策略尚未恢复，等待冷却后重试",
                         "retry_exhausted": "托管策略连续启动失败，已暂停重试，请检查 QMT 提示",
                     }[state]
+                elif state == "detection_only":
+                    target["state"] = "waiting_manual_start"
+                    target["message"] = "已检测到托管策略停止，当前 QMT 缺少自动恢复接口，请手动启动策略"
                 elif state == "unsupported" and target.get("state") != "running":
-                    target["message"] = recovery.get("error", "当前 QMT 版本尚未验证策略自动恢复")
+                    target["message"] = recovery.get("error", "当前 QMT 缺少策略运行检测接口")
         return status
 
     def start(self):

cfquant-0.2.62/cfquant/tests/test_qmt_strategy_capabilities.py

@@ -0,0 +1,189 @@
+"""Run the actual Frida agent against synthetic Qt exports; no live QMT."""
+import json
+from pathlib import Path
+import shutil
+import subprocess
+from types import SimpleNamespace
+
+import pytest
+
+from cfquant.qmt_component_login import _verify_environment_native
+
+
+AGENT = Path(__file__).resolve().parents[1] / 'qmt_strategy_agent.js'
+HARNESS = r'''
+const fs = require('fs'), vm = require('vm');
+const options = JSON.parse(fs.readFileSync(0, 'utf8'));
+let nextId = 1, hook, starts = 0, closes = 0, whitelistChecks = 0;
+class Pointer {
+  constructor(value = {}, offset = 0, id = nextId++) { this.value = value; this.offset = offset; this.id = id; }
+  add(offset) { return new Pointer(this.value, this.offset + offset, this.id); }
+  isNull() { return this.value === null; }
+  toString() { return String(this.id); }
+  readPointer() {
+    if (this.value.list) return this.value.list;
+    return this.value.items[(this.offset - 16) / 8];
+  }
+  readS32() { return this.offset === 8 ? 0 : this.value.items.length; }
+  readUtf16String() { return this.value.text; }
+  writeByteArray() {}
+  writeU64() {}
+}
+const target = {id:'7', name:'CFQ_TEST001_LITE', account:'TEST001', m_strAccountKey:'key',
+  runMode:'1', startupAutorun:'1', eStrategyType:'4', stock:'SH000300', peroid:'86400'};
+const models = [Object.assign({}, target, {running: options.running !== false})];
+const main = new Pointer({types:['TC::CMainWindow'], children:[]});
+const text = '[防外接] Python进程访问了网络地址 [192.0.2.1]，策略运行中止！';
+const content = new Pointer({types:[options.unqualified ? 'CSimpleTextWidget' : 'XP::CSimpleTextWidget'], text, children:[]});
+const container = new Pointer({types:['QWidget'], children:[content]});
+const notice = new Pointer({types:['XP::CGlobalMessageDialog'], children:[container]});
+if (options.duplicate) notice.value.children.push(new Pointer({types:['XP::CSimpleTextWidget'], text, children:[]}));
+if (options.unrelated) content.value.text = 'An unrelated message';
+const manager = new Pointer({});
+function call(symbol, args) {
+  const [a,b,c] = args;
+  if (symbol === 'DispatchMessageW') return;
+  if (symbol === 'GetWindowThreadProcessId') return 1;
+  if (symbol === 'PostMessageW') { setImmediate(() => hook.onLeave.call({threadId:1})); return true; }
+  if (symbol.startsWith('?find@QWidget')) return String(a) === '1' ? main : notice;
+  if (symbol.startsWith('?inherits@')) return a.value.types.includes(b.value.text);
+  if (symbol.startsWith('?isVisible@')) return a.value.visible !== false;
+  if (symbol.startsWith('??0QString')) { a.value.text = b.value.text; return a; }
+  if (symbol.startsWith('??1QString')) return;
+  if (symbol.startsWith('?size@QString')) return a.value.text.length;
+  if (symbol.startsWith('?utf16@QString')) return a;
+  if (symbol.startsWith('?instance@')) return manager;
+  if (symbol.startsWith('?saveSettings@')) { b.value.models = models; return; }
+  if (symbol.startsWith('?isFomrulaRun@')) return models.some(row => row.name === b.value.text && row.running);
+  if (symbol.startsWith('?isConnWhiteListReady@')) { whitelistChecks++; return options.whitelist !== false; }
+  if (symbol.startsWith('?runStrategy@')) { starts++; return; }
+  if (symbol.startsWith('??0QDomDocument') || symbol.startsWith('??1QDomDocument') || symbol.startsWith('??1QDomElement')) return;
+  if (symbol.startsWith('?createElement@')) return b;
+  if (symbol.startsWith('?firstChildElement@')) { b.value.models = a.value.models; b.value.index = 0; return b; }
+  if (symbol.startsWith('?nextSiblingElement@')) { b.value.models = a.value.models; b.value.index = a.value.index + 1; return b; }
+  if (symbol.startsWith('?isNull@QDomNode')) return a.value.index >= a.value.models.length;
+  if (symbol.startsWith('?attribute@')) { b.value.text = a.value.models[a.value.index][c.value.text]; return b; }
+  if (symbol.startsWith('?children@')) return new Pointer({list:new Pointer({items:a.value.children})});
+  if (symbol.startsWith('?getText@')) { b.value.text = a.value.text; return b; }
+  if (symbol.startsWith('?closeMessage@')) { closes++; notice.value.visible = false; return; }
+  throw new Error('Unimplemented test native call: ' + symbol);
+}
+const context = {
+  Process: {arch:'x64', pointerSize:8, findModuleByName: name => {
+    if ((options.missingModules || []).includes(name)) return null;
+    return {findExportByName: symbol => (options.missing || []).some(prefix => symbol.startsWith(prefix)) ? null : symbol};
+  }},
+  NativeFunction: function(symbol) { return (...args) => call(symbol, args); },
+  Memory: {alloc: () => new Pointer(), allocUtf8String: text => new Pointer({text}), allocUtf16String: text => new Pointer({text})},
+  Interceptor: {attach: (address, callbacks) => { hook = callbacks; }},
+  rpc: {exports:{}}, uint64: value => value, ptr: value => value, NULL:null, setTimeout, clearTimeout
+};
+vm.createContext(context);
+vm.runInContext(fs.readFileSync(options.agent, 'utf8'), context);
+(async () => {
+  const api = context.rpc.exports, result = {capabilities:api.strategycapabilities()};
+  if (result.capabilities.can_query) {
+    result.snapshot = (await api.strategystatus('1')).result;
+    if (options.tryStart) result.start = (await api.strategystart('1', Object.assign({}, target, options.expected || {}))).result;
+    if (options.notice) {
+      result.notice = (await api.illegalipnotice('2')).result;
+      if (result.notice) {
+        if (options.changed) content.value.text = text.replace('192.0.2.1','192.0.2.2');
+        result.dismiss = (await api.dismissillegalip('1','2',result.notice.text,[target])).result;
+      }
+    }
+  } else {
+    try { await api.strategystatus('1'); } catch (error) { result.query_error = error.message; }
+  }
+  result.starts = starts; result.closes = closes; result.whitelistChecks = whitelistChecks;
+  process.stdout.write(JSON.stringify(result));
+})().catch(error => { process.stdout.write(JSON.stringify({error:error.message,starts,closes})); });
+'''
+
+
+def run_agent(**options):
+    node = shutil.which('node')
+    assert node, 'Node is required to validate the actual strategy agent'
+    result = subprocess.run([node, '-e', HARNESS], input=json.dumps(dict(options, agent=str(AGENT))),
+                            text=True, encoding='utf-8', capture_output=True, check=True, timeout=15)
+    return json.loads(result.stdout)
+
+
+@pytest.mark.parametrize('missing', [['?isConnWhiteListReady@'], ['?runStrategy@'], ['?getText@'], ['?closeMessage@']])
+def test_optional_export_does_not_prevent_query(missing):
+    result = run_agent(missing=missing, tryStart=True, running=False)
+    assert result['snapshot']['models'][0]['running'] is False
+    assert result['capabilities']['can_query']
+    if missing[0] in ('?isConnWhiteListReady@', '?runStrategy@'):
+        assert not result['capabilities']['can_start']
+        assert result['start'] == {'outcome': 'detection_only', 'requested': False}
+        assert result['starts'] == 0
+    if missing[0] == '?isConnWhiteListReady@':
+        assert result['snapshot']['whitelist_ready'] is None
+
+
+@pytest.mark.parametrize('module', ['LoginDialog.dll', 'Dialog.dll', 'BaseWidget.dll'])
+def test_query_does_not_depend_on_login_or_notice_modules(module):
+    result = run_agent(missingModules=[module])
+    assert result['snapshot']['models'][0]['running'] is True
+    assert result['whitelistChecks'] == 0
+
+
+def test_missing_core_query_interface_is_explicit():
+    result = run_agent(missing=['?isFomrulaRun@'])
+    assert not result['capabilities']['can_query']
+    assert 'isFomrulaRun' in result['query_error']
+    assert result['starts'] == 0
+
+
+@pytest.mark.parametrize('running,whitelist,outcome,starts', [
+    (True, True, 'already_running', 0), (False, False, 'waiting_whitelist', 0),
+    (False, True, 'start_requested', 1),
+])
+def test_supported_start_keeps_native_guards(running, whitelist, outcome, starts):
+    result = run_agent(tryStart=True, running=running, whitelist=whitelist)
+    assert result['start']['outcome'] == outcome and result['starts'] == starts
+
+
+def test_start_rejects_changed_binding():
+    result = run_agent(tryStart=True, running=False, expected={'account':'WRONG'})
+    assert 'binding changed' in result['error'] and result['starts'] == 0
+
+
+@pytest.mark.parametrize('options,outcome', [({}, 'closed'), ({'unqualified':True}, 'closed'), ({'changed':True}, 'message_changed'),
+                                           ({'missing':['?closeMessage@']}, 'notice_close_unavailable')])
+def test_notice_uses_nested_widget_types_and_rechecks_text(options, outcome):
+    result = run_agent(notice=True, **options)
+    assert result['notice']['hwnd'] == '2'
+    assert result['dismiss']['outcome'] == outcome
+    assert result['closes'] == (1 if outcome == 'closed' else 0)
+
+
+@pytest.mark.parametrize('options', [{'duplicate':True}, {'unrelated':True}, {'missingModules':['BaseWidget.dll']}])
+def test_ambiguous_unrelated_or_unsupported_notice_is_not_closed(options):
+    result = run_agent(notice=True, **options)
+    assert result['notice'] is None and result['closes'] == 0
+    assert result['snapshot']['models'][0]['running'] is True
+
+
+@pytest.mark.parametrize('qt_version', [(5,6,2), (5,9,9), (5,15,2), (6,5,0)])
+def test_strategy_environment_checks_qt_abi_without_exact_version_pin(tmp_path, monkeypatch, qt_version):
+    from cfquant import qmt_dependencies
+    data = bytearray(128)
+    data[0x3c:0x40] = (64).to_bytes(4, 'little')
+    data[68:70] = (0x8664).to_bytes(2, 'little')
+    (tmp_path / 'XtItClient.exe').write_bytes(data)
+    major, minor, patch = qt_version
+    api = SimpleNamespace(GetFileVersionInfo=lambda *args: {'FileVersionMS': (major << 16) | minor, 'FileVersionLS': patch << 16})
+    monkeypatch.setattr(qmt_dependencies, 'import_login_module', lambda name: api)
+    if major == 5:
+        _verify_environment_native(tmp_path, strategy=True)
+    else:
+        with pytest.raises(RuntimeError, match='ABI'):
+            _verify_environment_native(tmp_path, strategy=True)
+    # Login retains its existing independently validated compatibility policy.
+    if qt_version == (5,6,2):
+        _verify_environment_native(tmp_path)
+    else:
+        with pytest.raises(RuntimeError, match='5.6.2'):
+            _verify_environment_native(tmp_path)