cfquant 0.2.53__tar.gz → 0.2.54__tar.gz

{cfquant-0.2.53 → cfquant-0.2.54}/MANIFEST.in

@@ -4,6 +4,7 @@ include cfquant_web_server.py
 include cfquant_pipe_hub.py
 
 recursive-include cfquant *.py
+include cfquant/qmt_component_agent.js
 recursive-include cfquant/tests *.py *.md
 recursive-include LTtx *.py
 include LTtx/tx/Config.txt

{cfquant-0.2.53 → cfquant-0.2.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.53
+Version: 0.2.54
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8
@@ -14,6 +14,8 @@ 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: pywin32>=306; sys_platform == "win32"
 Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == "dev"
 Requires-Dist: twine>=5.0; extra == "dev"

cfquant-0.2.54/cfquant/qmt_component_agent.js

@@ -0,0 +1,249 @@
+'use strict';
+
+const core = Process.getModuleByName('Qt5Core.dll');
+const widgets = Process.getModuleByName('Qt5Widgets.dll');
+const user32 = Process.getModuleByName('user32.dll');
+const fn = (mod, name, ret, args) => new NativeFunction(mod.getExportByName(name), ret, args);
+const findWidget = fn(widgets, '?find@QWidget@@SAPEAV1@_K@Z', 'pointer', ['uint64']);
+const children = fn(core, '?children@QObject@@QEBAAEBV?$QList@PEAVQObject@@@@XZ', 'pointer', ['pointer']);
+const inherits = fn(core, '?inherits@QObject@@QEBA_NPEBD@Z', 'bool', ['pointer', 'pointer']);
+const className = fn(core, '?className@QMetaObject@@QEBAPEBDXZ', 'pointer', ['pointer']);
+const isVisible = fn(widgets, '?isVisible@QWidget@@QEBA_NXZ', 'bool', ['pointer']);
+const isEnabled = fn(widgets, '?isEnabled@QWidget@@QEBA_NXZ', 'bool', ['pointer']);
+const echoMode = fn(widgets, '?echoMode@QLineEdit@@QEBA?AW4EchoMode@1@XZ', 'int', ['pointer']);
+const setText = fn(widgets, '?setText@QLineEdit@@QEAAXAEBVQString@@@Z', 'void', ['pointer', 'pointer']);
+const stringCtor = fn(core, '??0QString@@QEAA@PEBVQChar@@H@Z', 'pointer', ['pointer', 'pointer', 'int']);
+const stringDtor = fn(core, '??1QString@@QEAA@XZ', 'void', ['pointer']);
+const stringSize = fn(core, '?size@QString@@QEBAHXZ', 'int', ['pointer']);
+const stringData = fn(core, '?utf16@QString@@QEBAPEBGXZ', 'pointer', ['pointer']);
+const buttonText = fn(widgets, '?text@QAbstractButton@@QEBA?AVQString@@XZ', 'pointer', ['pointer', 'pointer']);
+const editText = fn(widgets, '?text@QLineEdit@@QEBA?AVQString@@XZ', 'pointer', ['pointer', 'pointer']);
+const labelText = fn(widgets, '?text@QLabel@@QEBA?AVQString@@XZ', 'pointer', ['pointer', 'pointer']);
+const buttonClick = fn(widgets, '?click@QAbstractButton@@QEAAXXZ', 'void', ['pointer']);
+const closeWidget = fn(widgets, '?close@QWidget@@QEAA_NXZ', 'bool', ['pointer']);
+const comboEditable = fn(widgets, '?isEditable@QComboBox@@QEBA_NXZ', 'bool', ['pointer']);
+const comboSetText = fn(widgets, '?setEditText@QComboBox@@QEAAXAEBVQString@@@Z', 'void', ['pointer', 'pointer']);
+const getThread = fn(user32, 'GetWindowThreadProcessId', 'uint32', ['pointer', 'pointer']);
+const postMessage = fn(user32, 'PostMessageW', 'bool', ['pointer', 'uint32', 'pointer', 'pointer']);
+const typeNames = new Map();
+let pending = null;
+
+function hasType(object, name) {
+  if (!typeNames.has(name)) typeNames.set(name, Memory.allocUtf8String(name));
+  return inherits(object, typeNames.get(name));
+}
+
+function typeName(object) {
+  const metaFn = new NativeFunction(object.readPointer().readPointer(), 'pointer', ['pointer']);
+  return className(metaFn(object)).readUtf8String();
+}
+
+function childObjects(object) {
+  const d = children(object).readPointer();
+  const begin = d.add(8).readS32(), end = d.add(12).readS32();
+  if (begin < 0 || end < begin || end - begin > 5000) throw new Error('Unexpected QList layout');
+  const result = [];
+  for (let i = begin; i < end; i++) result.push(d.add(16 + i * Process.pointerSize).readPointer());
+  return result;
+}
+
+function label(object) {
+  const result = Memory.alloc(Process.pointerSize);
+  buttonText(object, result);
+  try { return stringData(result).readUtf16String(stringSize(result)); }
+  finally { stringDtor(result); }
+}
+
+function walk(root) {
+  const result = [], queue = [{object: root, parent: null}], seen = new Set();
+  while (queue.length) {
+    const item = queue.shift(), object = item.object;
+    if (object.isNull() || seen.has(object.toString())) continue;
+    seen.add(object.toString());
+    if (seen.size > 5000) throw new Error('Object tree too large');
+    const isWidget = hasType(object, 'QWidget');
+    const row = {address: object.toString(), parent: item.parent, class_name: typeName(object)};
+    if (isWidget) {
+      row.visible = isVisible(object);
+      row.enabled = isEnabled(object);
+      if (hasType(object, 'QLineEdit')) row.echo_mode = echoMode(object);
+      if (hasType(object, 'QAbstractButton')) row.label = label(object);
+    }
+    result.push(row);
+    childObjects(object).forEach(child => queue.push({object: child, parent: object.toString()}));
+  }
+  return result;
+}
+
+function getRoot(hwnd) {
+  const root = findWidget(uint64(hwnd));
+  if (root.isNull()) throw new Error('No Qt widget for target window');
+  return root;
+}
+
+function passwordEditor(root, requireEnabled = true) {
+  if (!hasType(root, 'TC::CLoginDialog')) throw new Error('Not a QMT login dialog');
+  const rows = walk(root);
+  const edits = rows.filter(row => row.echo_mode === 2 && row.visible && (!requireEnabled || row.enabled));
+  if (edits.length !== 1) throw new Error('Expected exactly one visible password editor');
+  return {rows, editor: ptr(edits[0].address)};
+}
+
+function hasText(editor) {
+  const value = Memory.alloc(Process.pointerSize);
+  editText(editor, value);
+  // Only return emptiness; never copy a remembered password out of the process.
+  try { return stringSize(value) > 0; }
+  finally { stringDtor(value); }
+}
+
+function noticeKind(rows) {
+  let credential = false, network = false;
+  for (const row of rows) {
+    const object = ptr(row.address);
+    if (!row.visible || !hasType(object, 'QLabel')) continue;
+    const value = Memory.alloc(Process.pointerSize);
+    labelText(object, value);
+    let text;
+    try { text = stringData(value).readUtf16String(stringSize(value)); }
+    finally { stringDtor(value); }
+    if (/验证码|动态口令|短信验证|captcha/i.test(text)) return 'challenge';
+    if (/密码.{0,12}(错误|不正确|失败|无效)|口令.{0,12}(错误|不正确|失败)|password.{0,16}(incorrect|invalid|wrong)/i.test(text)) credential = true;
+    if (/(网络|连接|服务器).{0,16}(失败|超时|异常)|network.{0,16}(error|timeout)/i.test(text)) network = true;
+  }
+  return credential ? 'credential_error' : network ? 'network_error' : null;
+}
+
+function submit(root) {
+  passwordEditor(root);
+  const login = fn(Process.getModuleByName('LoginDialog.dll'),
+    '?slot_loginClicked@CLoginDialog@TC@@QEAAXXZ', 'void', ['pointer']);
+  login(root);
+}
+
+function loginIdentity(root) {
+  const getName = fn(Process.getModuleByName('LoginDialog.dll'),
+    '?getUserName@CLoginDialog@TC@@IEAA?AVQString@@XZ', 'pointer', ['pointer', 'pointer']);
+  const value = Memory.alloc(Process.pointerSize);
+  getName(root, value);
+  try { return stringData(value).readUtf16String(stringSize(value)); }
+  finally { stringDtor(value); }
+}
+
+function onGui(hwnd, operation) {
+  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};
+    // Wake the normal message loop without mouse/keyboard events or foreground changes.
+    postMessage(ptr(hwnd), 0, NULL, NULL);
+  });
+}
+
+Interceptor.attach(user32.getExportByName('DispatchMessageW'), {
+  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); }
+  }
+});
+
+rpc.exports = {
+  selectaccount(hwnd, account, replace = false) {
+    return onGui(hwnd, () => {
+      const root = getRoot(hwnd);
+      passwordEditor(root);
+      if (!replace && loginIdentity(root) === account) return {changed: false};
+      const candidates = walk(root).filter(row => row.visible && row.enabled &&
+        hasType(ptr(row.address), 'QComboBox') && comboEditable(ptr(row.address)));
+      if (candidates.length !== 1) throw new Error('No unique editable account selector');
+      if (replace) {
+        const empty = Memory.alloc(Process.pointerSize);
+        stringCtor(empty, Memory.allocUtf16String(''), 0);
+        try { comboSetText(ptr(candidates[0].address), empty); }
+        finally { stringDtor(empty); }
+      }
+      const data = Memory.allocUtf16String(account), value = Memory.alloc(Process.pointerSize);
+      stringCtor(value, data, account.length);
+      try { comboSetText(ptr(candidates[0].address), value); }
+      finally { stringDtor(value); }
+      if (loginIdentity(root) !== account) throw new Error('Could not select configured login account');
+      return {changed: true};
+    });
+  },
+  inspect(hwnd) { return onGui(hwnd, () => walk(getRoot(hwnd))); },
+  status(hwnd) {
+    return onGui(hwnd, () => {
+      const root = getRoot(hwnd);
+      if (!hasType(root, 'TC::CLoginDialog')) return {is_login: false, is_main: hasType(root, 'TC::CMainWindow')};
+      const rows = walk(root);
+      const edits = rows.filter(row => row.echo_mode === 2 && row.visible);
+      if (edits.length > 1) throw new Error('Multiple password editors are visible');
+      return {is_login: true, has_password: edits.length === 1 && hasText(ptr(edits[0].address)),
+        busy: edits.length === 0, login_identity: loginIdentity(root), notice: noticeKind(rows),
+        login_enabled: rows.some(row => row.visible && row.enabled && /^登\s*录(?:[（(]\d+[)）])?$/.test(row.label || ''))};
+    });
+  },
+  notice(hwnd) {
+    return onGui(hwnd, () => {
+      const rows = walk(getRoot(hwnd));
+      return {kind: noticeKind(rows)};
+    });
+  },
+  acknowledge(hwnd) {
+    return onGui(hwnd, () => {
+      const rows = walk(getRoot(hwnd));
+      if (noticeKind(rows) !== 'credential_error') throw new Error('Not a recognized credential failure');
+      const buttons = rows.filter(row => row.visible && row.enabled && /^(确定|确认|OK|&OK)$/.test(row.label || ''));
+      if (buttons.length !== 1) throw new Error('No unique acknowledgement button');
+      buttonClick(ptr(buttons[0].address));
+      return {acknowledged: true};
+    });
+  },
+  submit(hwnd) { return onGui(hwnd, () => { submit(getRoot(hwnd)); return {submitted: true}; }); },
+  close(hwnd) { return onGui(hwnd, () => ({closed: closeWidget(getRoot(hwnd))})); },
+  clicklabel(hwnd, text) {
+    return onGui(hwnd, () => {
+      const rows = walk(getRoot(hwnd)).filter(row => row.label === text && row.visible && row.enabled);
+      if (rows.length !== 1) throw new Error('Expected one matching enabled button');
+      buttonClick(ptr(rows[0].address));
+      return {clicked: true};
+    });
+  },
+  fill(hwnd, value, submit) {
+    return onGui(hwnd, () => {
+      const root = getRoot(hwnd);
+      if (!hasType(root, 'TC::CLoginDialog')) throw new Error('Not a QMT login dialog');
+      const rows = walk(root);
+      const edits = rows.filter(row => row.echo_mode === 2 && row.visible && row.enabled);
+      if (edits.length !== 1) throw new Error('Expected exactly one visible password editor');
+      const text = Memory.allocUtf16String(value);
+      const string = Memory.alloc(Process.pointerSize);
+      stringCtor(string, text, value.length);
+      try { setText(ptr(edits[0].address), string); }
+      finally {
+        stringDtor(string);
+        text.writeByteArray(new Uint8Array((value.length + 1) * 2));
+      }
+      const count = value.length;
+      value = null;
+      if (submit) {
+        const login = fn(Process.getModuleByName('LoginDialog.dll'),
+          '?slot_loginClicked@CLoginDialog@TC@@QEAAXXZ', 'void', ['pointer']);
+        login(root);
+      }
+      return {filled: true, submitted: Boolean(submit), characters: count,
+              input_method: 'QLineEdit::setText', login_method: submit ? 'CLoginDialog::slot_loginClicked' : null};
+    });
+  }
+};

cfquant-0.2.54/cfquant/qmt_component_login.py

@@ -0,0 +1,310 @@
+"""Explicit QMT component login for a configured binding (Windows, Qt 5.6.2 x64).
+
+Run with --binding NAME. Password is requested only if needed, using --prompt
+or stdin. This tool never starts/stops QMT; it replaces the login form contents.
+The web auto-start service also uses login_running_qmt after starting a process.
+"""
+import argparse
+import getpass
+import json
+from pathlib import Path
+import sys
+import time
+
+
+class QmtNotReady(RuntimeError):
+    pass
+
+
+def verify_environment(directory):
+    """Validate dependencies and native ABI before stopping a running terminal."""
+    import frida  # noqa: F401
+    import win32api
+    import win32crypt  # noqa: F401
+    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):
+            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 位客户端")
+
+
+def auto_login(backend, password_provider):
+    """Replace existing password contents and submit the supplied credential once."""
+    attempts = []
+    password_requested = False
+
+    def result(outcome):
+        return {"outcome": outcome, "login_succeeded": outcome in ("logged_in", "already_logged_in"),
+                "attempts": attempts, "password_requested": password_requested}
+
+    if backend.already_logged_in():
+        return result("already_logged_in")
+    state = backend.state()
+    if state.get("busy"):
+        return result("login_not_ready")
+    if state.get("notice") in ("challenge", "network_error"):
+        return result(state["notice"])
+    if state.get("notice") == "credential_error":
+        backend.acknowledge_failure()
+    password_requested = True
+    password = password_provider()
+    if not password:
+        return result("password_required")
+    try:
+        backend.fill(password)
+    finally:
+        password = None
+    if not backend.state()["login_enabled"]:
+        return result("login_not_ready")
+    backend.submit()
+    attempts.append("provided")
+    return result(backend.wait_outcome())
+
+
+def select_binding(config_path, name):
+    config = json.loads(Path(config_path).read_text(encoding="utf-8"))
+    rows = config.get("account_configs") or {}
+    rows = rows.values() if isinstance(rows, dict) else rows
+    matches = [row for row in rows if row.get("display_name") == name]
+    if len(matches) != 1:
+        raise ValueError("Expected exactly one binding with that display name")
+    root = Path(matches[0]["qmt_dir"]).resolve()
+    for directory in (root, root / "bin.x64"):
+        if (directory / "XtItClient.exe").is_file():
+            return matches[0], directory
+    raise ValueError("Binding directory does not contain XtItClient.exe")
+
+
+class QtLoginBackend:
+    def __init__(self, directory, timeout=40, expected_pid=None):
+        import frida
+        import psutil
+        import win32api
+        import win32event
+        import win32gui
+        import win32process
+        self.gui, self.process = win32gui, win32process
+        self.timeout = timeout
+        self.hwnd = None
+        self.identity = None
+        self.failure_hwnd = None
+        self.session = None
+        self.mutex = None
+        self.messages = []
+        self.foreground_before = win32gui.GetForegroundWindow()
+        expected = (directory / "XtItClient.exe").resolve()
+        matches = []
+        for process in psutil.process_iter(["name"]):
+            try:
+                if (process.info["name"] or "").lower() == "xtitclient.exe" and Path(process.exe()).resolve() == expected:
+                    matches.append(process)
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                continue
+        if not matches:
+            raise QmtNotReady("QMT process is not ready")
+        if len(matches) != 1:
+            raise RuntimeError("Expected exactly one running QMT for this binding directory")
+        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)
+        self.mutex = win32event.CreateMutex(None, False, "Local\\CFQuantQmtComponentLogin_" + str(self.pid))
+        acquired = win32event.WaitForSingleObject(self.mutex, 0)
+        if acquired not in (0, 0x80):
+            win32api.CloseHandle(self.mutex)
+            self.mutex = None
+            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);")
+            readiness.load()
+            ready = readiness.exports_sync.ready()
+            readiness.unload()
+            if not ready:
+                raise QmtNotReady("QMT login modules are still loading")
+            script = self.session.create_script(Path(__file__).with_name("qmt_component_agent.js").read_text(encoding="utf-8"))
+            script.on("message", lambda message, data: self.messages.append("agent_error") if message.get("type") == "error" else None)
+            script.load()
+            self.script, self.api = script, script.exports_sync
+            self.existing_main = False
+            self.main_hwnd = None
+            for hwnd in self.windows():
+                state = self.api.status(str(hwnd))["result"]
+                if state.get("is_login"):
+                    if self.hwnd is not None:
+                        raise RuntimeError("Multiple login dialogs found")
+                    self.hwnd = hwnd
+                    self.identity = state["login_identity"]
+                elif state.get("is_main"):
+                    self.existing_main = True
+                    self.main_hwnd = hwnd
+            if self.hwnd is None and not self.existing_main:
+                raise QmtNotReady("No supported login or main window found yet")
+            self.minimized_before = bool(self.hwnd and self.gui.IsIconic(self.hwnd))
+        except Exception:
+            self.close()
+            raise
+
+    def windows(self):
+        result = []
+        def visit(hwnd, _):
+            if self.process.GetWindowThreadProcessId(hwnd)[1] == self.pid and self.gui.IsWindowVisible(hwnd) and self.gui.GetClassName(hwnd).startswith("Qt"):
+                result.append(hwnd)
+        self.gui.EnumWindows(visit, None)
+        return result
+
+    def already_logged_in(self):
+        return self.existing_main and self.hwnd is None
+
+    def state(self):
+        state = self.api.status(str(self.hwnd))["result"]
+        if not state.get("is_login") or not self.identity or state.get("login_identity") != self.identity:
+            raise RuntimeError("Login window or selected account changed; stopping")
+        state.pop("login_identity", None)
+        for hwnd in self.windows():
+            if hwnd != self.hwnd and hwnd != self.main_hwnd:
+                kind = self.api.notice(str(hwnd))["result"].get("kind")
+                if kind:
+                    state["notice"] = kind
+                    self.failure_hwnd = hwnd
+                    break
+        return state
+
+    def select_account(self, account, replace=False):
+        if self.already_logged_in():
+            if account and not self.gui.GetWindowText(self.main_hwnd).startswith(account + " - "):
+                raise RuntimeError("QMT 已登录的用户与配置的登录账号不一致，请重启该绑定 QMT")
+            return
+        if account and (replace or account != self.identity):
+            self.api.selectaccount(str(self.hwnd), account, replace)
+            self.identity = account
+            # Managed login clears remembered contents even for the same user.
+            self.api.fill(str(self.hwnd), "", False)
+
+    def submit(self):
+        state = self.state()
+        if not state["has_password"] or not state["login_enabled"]:
+            raise RuntimeError("Login is not ready")
+        self.api.submit(str(self.hwnd))
+
+    def fill(self, password):
+        self.state()
+        self.api.fill(str(self.hwnd), password, False)
+
+    def wait_outcome(self):
+        deadline = time.monotonic() + self.timeout
+        while time.monotonic() < deadline:
+            windows = self.windows()
+            for hwnd in windows:
+                caption = self.gui.GetWindowText(hwnd)
+                if self.identity and caption.startswith(self.identity + " - "):
+                    if self.api.status(str(hwnd))["result"].get("is_main"):
+                        return "logged_in"
+            for hwnd in windows:
+                if hwnd == self.hwnd:
+                    try:
+                        state = self.state()
+                    except Exception:
+                        if not self.gui.IsWindow(hwnd) or not self.gui.IsWindowVisible(hwnd):
+                            continue
+                        raise
+                    kind = state.get("notice")
+                    if not state["login_enabled"]:
+                        continue
+                else:
+                    kind = self.api.notice(str(hwnd))["result"].get("kind")
+                if kind:
+                    self.failure_hwnd = hwnd
+                    return kind
+            time.sleep(0.5)
+        # A slow connection is not evidence of a wrong password. Never resubmit.
+        return "timeout"
+
+    def acknowledge_failure(self):
+        if self.failure_hwnd and self.failure_hwnd != self.hwnd:
+            self.api.acknowledge(str(self.failure_hwnd))
+        self.failure_hwnd = None
+
+    def close(self):
+        import win32api
+        import win32event
+        try:
+            if self.session:
+                self.session.detach()
+                self.session = None
+        finally:
+            if self.mutex:
+                win32event.ReleaseMutex(self.mutex)
+                win32api.CloseHandle(self.mutex)
+                self.mutex = None
+
+
+def main():
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--binding", required=True)
+    parser.add_argument("--config", type=Path, default=Path(__file__).resolve().parents[1] / "runtime/config/cfquant_web_config.json")
+    parser.add_argument("--prompt", action="store_true", help="Read a needed password without echo; otherwise read one line of stdin")
+    parser.add_argument("--timeout", type=float, default=40)
+    parser.add_argument("--report", type=Path)
+    args = parser.parse_args()
+    if not 1 <= args.timeout <= 120:
+        parser.error("timeout must be between 1 and 120 seconds")
+    row, directory = select_binding(args.config, args.binding)
+    backend = QtLoginBackend(directory, args.timeout)
+    try:
+        backend.select_account((row.get("qmt_auto_login") or {}).get("login_account", ""), replace=True)
+        def read_password():
+            return getpass.getpass("QMT password (hidden): ") if args.prompt else sys.stdin.readline().rstrip("\r\n")
+        result = auto_login(backend, read_password)
+        result.update(binding=args.binding, process_id=backend.pid,
+                      minimized_before=backend.minimized_before,
+                      foreground_before=backend.foreground_before,
+                      foreground_after=backend.gui.GetForegroundWindow(),
+                      script_errors=backend.messages,
+                      input_method="Qt native methods; no keyboard/mouse input")
+        output = json.dumps(result, ensure_ascii=False, indent=2)
+        if args.report:
+            args.report.write_text(output, encoding="utf-8")
+        print(output)
+        return 0 if result["outcome"] in ("logged_in", "already_logged_in") else 1
+    finally:
+        backend.close()
+
+
+def login_running_qmt(directory, login_account="", password_provider=lambda: "", expected_pid=None,
+                      startup_timeout=60, timeout=40):
+    """Wait for a freshly launched QMT, then execute one bounded login flow."""
+    deadline = time.monotonic() + startup_timeout
+    while True:
+        try:
+            backend = QtLoginBackend(Path(directory), timeout, expected_pid=expected_pid)
+            break
+        except QmtNotReady:
+            if time.monotonic() >= deadline:
+                return {"outcome": "startup_timeout", "login_succeeded": False, "attempts": []}
+            time.sleep(0.5)
+    try:
+        if not backend.already_logged_in() and backend.state().get("busy"):
+            outcome = backend.wait_outcome()
+            if outcome == "logged_in":
+                # Reopen only the automation session to verify the resulting user.
+                backend.close()
+                backend = QtLoginBackend(Path(directory), timeout, expected_pid=expected_pid)
+            elif outcome != "credential_error":
+                return {"outcome": outcome, "login_succeeded": False, "attempts": []}
+        backend.select_account(login_account, replace=True)
+        return auto_login(backend, password_provider)
+    finally:
+        backend.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

cfquant-0.2.54/cfquant/qmt_credentials.py

@@ -0,0 +1,72 @@
+"""Local QMT credentials protected for the current Windows user with DPAPI."""
+import base64
+import hashlib
+import json
+import os
+from pathlib import Path
+import threading
+
+_LOCK = threading.RLock()
+
+
+def directory_key(directory):
+    root = Path(directory).resolve()
+    if root.name.lower() in ("bin.x64", "python"):
+        root = root.parent
+    return hashlib.sha256(os.path.normcase(str(root)).encode("utf-8")).hexdigest()
+
+
+def _protect(value, entropy):
+    import win32crypt
+    return win32crypt.CryptProtectData(value, "CFQuant QMT login", entropy, None, None, 1)
+
+
+def _unprotect(value, entropy):
+    import win32crypt
+    return win32crypt.CryptUnprotectData(value, entropy, None, None, 1)[1]
+
+
+class QmtCredentialStore:
+    def __init__(self, config_path):
+        self.path = Path(config_path).with_name("qmt_login_credentials.json")
+
+    def _read(self):
+        if not self.path.exists():
+            return {}
+        return json.loads(self.path.read_text(encoding="utf-8"))
+
+    def has(self, directory, login_account):
+        if not directory:
+            return False
+        with _LOCK:
+            entry = self._read().get(directory_key(directory), {})
+            return bool(entry.get("secret") and entry.get("login_account") == login_account)
+
+    def save(self, directory, login_account, password):
+        if not directory or not login_account:
+            raise ValueError("保存 QMT 密码时必须填写 QMT 目录和登录账号")
+        if not isinstance(password, str) or not password or len(password) > 1024:
+            raise ValueError("QMT 密码不能为空或超过 1024 字符")
+        key = directory_key(directory)
+        try:
+            encrypted = _protect(password.encode("utf-8"), key.encode("ascii"))
+        except Exception:
+            raise RuntimeError("无法使用当前 Windows 用户加密 QMT 密码，请检查 pywin32 安装") from None
+        with _LOCK:
+            data = self._read()
+            data[key] = {"login_account": login_account, "secret": base64.b64encode(encrypted).decode("ascii")}
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            temp = self.path.with_suffix(".%s.tmp" % os.getpid())
+            temp.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+            os.replace(str(temp), str(self.path))
+
+    def password(self, directory, login_account):
+        key = directory_key(directory)
+        with _LOCK:
+            entry = self._read().get(key, {})
+        if not entry or entry.get("login_account") != login_account:
+            return ""
+        try:
+            return _unprotect(base64.b64decode(entry["secret"]), key.encode("ascii")).decode("utf-8")
+        except Exception:
+            raise RuntimeError("无法解密 QMT 密码，请使用保存密码时的 Windows 用户运行，或重新保存密码") from None

{cfquant-0.2.53 → cfquant-0.2.54}/cfquant/tests/15_/347/275/221/351/241/265/347/212/266/346/200/201/347/274/223/345/255/230/346/265/213/350/257/225.py

@@ -932,7 +932,7 @@ def test_save_account_runtime_config_parses_string_disabled(monkeypatch, tmp_pat
     monkeypatch.setattr(web, "CALLBACKS", SimpleNamespace(refresh_channels=lambda channels: None))
     monkeypatch.setattr(web, "callback_channels", lambda: [])
 
-    result = web.save_account_runtime_config({
+    result = web.save_account_runtime_config({"qmt_auto_login": {"enabled": False},
         "account_id": "77557115",
         "account_type": "stock",
         "enabled": "false",

{cfquant-0.2.53 → cfquant-0.2.54}/cfquant/tests/test_lite_deployment_paths.py

@@ -44,6 +44,7 @@ def assert_lite_package(manager, root):
 def web_deployment(deployment, tmp_path, monkeypatch):
     import cfquant_web_server as web
     manager, row, infos, running, root = deployment
+    row['qmt_auto_login'] = {'enabled': False}
     config = web.WebRuntimeConfig(str(tmp_path / "web.json"), str(tmp_path / "web.db"))
     config._data["account_configs"] = {row["account_key"]: row}
     monkeypatch.setattr(web, "WEB_CONFIG", config)