cfquant 0.2.53__tar.gz → 0.2.55__tar.gz

{cfquant-0.2.53 → cfquant-0.2.55}/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.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.53
+Version: 0.2.55
 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.53 → cfquant-0.2.55}/cfquant/_editable_install.py

@@ -9,6 +9,11 @@ import sys
 import tempfile
 from pathlib import Path
 
+if __package__:
+    from .qmt_dependencies import report_startup_dependencies
+else:
+    from qmt_dependencies import report_startup_dependencies
+
 
 PACKAGE_NAME = "cfquant"
 
@@ -503,6 +508,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)
         return 0
 
     command = editable_install_args(project_root, python_exe)
@@ -526,6 +532,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)
     return 0
 
 

cfquant-0.2.55/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.55/cfquant/qmt_component_login.py

@@ -0,0 +1,321 @@
+"""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."""
+    try:
+        from .qmt_dependencies import LOGIN_MODULES, import_login_module
+    except ImportError:
+        from qmt_dependencies import LOGIN_MODULES, import_login_module
+    modules = {name: import_login_module(name) for name in LOGIN_MODULES}
+    win32api = modules["win32api"]
+    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):
+        try:
+            from .qmt_dependencies import import_login_module
+        except ImportError:
+            from qmt_dependencies import import_login_module
+        import psutil
+        frida = import_login_module("frida")
+        win32api = import_login_module("win32api")
+        win32event = import_login_module("win32event")
+        win32gui = import_login_module("win32gui")
+        win32process = import_login_module("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):
+        try:
+            from .qmt_dependencies import import_login_module
+        except ImportError:
+            from qmt_dependencies import import_login_module
+        win32api = import_login_module("win32api")
+        win32event = import_login_module("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())