cfquant 0.2.68__tar.gz → 0.2.71__tar.gz

{cfquant-0.2.68 → cfquant-0.2.71}/PKG-INFO

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

{cfquant-0.2.68 → cfquant-0.2.71}/cfquant/qmt_python_runtime.py

@@ -15,7 +15,9 @@ from __future__ import annotations
 from dataclasses import dataclass, asdict
 import configparser
 import hashlib
+import http.client
 import json
+import logging
 import os
 from pathlib import Path
 import re
@@ -26,6 +28,7 @@ import time
 from typing import Dict, Optional
 import urllib.error
 import urllib.request
+from urllib.parse import urlencode
 import zipfile
 
 
@@ -33,6 +36,16 @@ class QmtPythonRuntimeError(RuntimeError):
     """A download, validation, activation, or restart operation failed."""
 
 
+class _DownloadSourceError(QmtPythonRuntimeError):
+    """A remote failure that permits trying another copy of the same package."""
+
+
+class _NoMirrorRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        # Never forward the shared mirror key to a redirected host.
+        return None
+
+
 @dataclass(frozen=True)
 class QmtPythonPackage:
     runtime: str
@@ -41,6 +54,8 @@ class QmtPythonPackage:
     filename: str
     md5: str
     force_update: bool = False
+    sha256: str = ""
+    size: int = 0
 
     def as_dict(self):
         return asdict(self)
@@ -67,6 +82,10 @@ _RUNTIME_ALIASES = {"36": "py36", "3.6": "py36", "python36": "py36",
 _PY312_MIN_QMT_VERSION = (2, 1, 33, 0)
 _CONFIG_LOCKS: Dict[str, threading.RLock] = {}
 _CONFIG_LOCKS_GUARD = threading.Lock()
+_MIRROR_BASE = "https://cfquant.org/api/qmt/python-runtime/"
+_MIRROR_KEY_HEADER = "X-CFQuant-Runtime-Key"
+_MIRROR_KEY = "cfq-runtime-v1-4859bf5af16942e38b30f128bd540714"
+_LOG = logging.getLogger(__name__)
 
 
 def _canonical_runtime(runtime: str) -> str:
@@ -118,6 +137,10 @@ class QmtPythonRuntime:
         self.staging_dir = self.state_dir / "staging"
         self.backup_dir = self.state_dir / "backups"
         self._opener = opener or urllib.request.build_opener(urllib.request.ProxyHandler({}))
+        self._mirror_opener = opener or urllib.request.build_opener(
+            urllib.request.ProxyHandler({}), _NoMirrorRedirect())
+        self._mirror_cache = None
+        self._mirror_checked_at = float("-inf")
         self._lock = self._lock_for(str(self.bin_dir))
 
     @staticmethod
@@ -131,10 +154,50 @@ class QmtPythonRuntime:
 
     def _request(self, url, *, headers=None, timeout=None):
         request = urllib.request.Request(url, headers=headers or {}, method="GET")
-        return self._opener.open(request, timeout=timeout or self.timeout)
+        opener = self._mirror_opener if url.startswith(_MIRROR_BASE) else self._opener
+        return opener.open(request, timeout=timeout or self.timeout)
+
+    def _mirror_status(self):
+        if time.monotonic() - self._mirror_checked_at < 5:
+            return self._mirror_cache
+        self._mirror_checked_at = time.monotonic()
+        self._mirror_cache = None
+        try:
+            with self._request(_MIRROR_BASE + "status", headers={_MIRROR_KEY_HEADER: _MIRROR_KEY},
+                               timeout=min(self.timeout, 5)) as response:
+                data = json.loads(response.read(65537).decode("utf-8"))
+            if (not data.get("ok") or data.get("schema") != 1 or not isinstance(data.get("packages"), dict)
+                    or not isinstance(data.get("busy"), bool)):
+                raise ValueError("invalid mirror status")
+            self._mirror_cache = data
+        except (OSError, ValueError, AttributeError, http.client.HTTPException) as exc:
+            _LOG.info("QMT runtime mirror status unavailable: %s", exc)
+        return self._mirror_cache
+
+    @staticmethod
+    def _package_from_mirror(data, runtime):
+        try:
+            item = data["packages"][runtime]
+            if (not re.fullmatch(r"[A-Za-z0-9_.-]+\.zip", item["filename"])
+                    or not re.fullmatch(r"[0-9a-f]{32}", item["md5"])
+                    or not re.fullmatch(r"[0-9a-f]{64}", item["sha256"])
+                    or not item["url"].startswith(("http://", "https://"))
+                    or int(item["size"]) <= 0):
+                return None
+            return QmtPythonPackage(runtime, item["version"], item["url"], item["filename"],
+                                    item["md5"], bool(item.get("force_update")),
+                                    item["sha256"], int(item["size"]))
+        except (KeyError, TypeError, ValueError, AttributeError):
+            return None
 
     def fetch_package(self, runtime="py312") -> QmtPythonPackage:
         runtime = _canonical_runtime(runtime)
+        mirrored = self._package_from_mirror(self._mirror_status(), runtime)
+        if mirrored:
+            return mirrored
+        return self._fetch_upstream_package(runtime)
+
+    def _fetch_upstream_package(self, runtime):
         cfg_url = "http://download.thinktrader.net:8800/download/" + _CONFIG_NAMES[runtime]
         try:
             with self._request(cfg_url) as response:
@@ -350,68 +413,127 @@ class QmtPythonRuntime:
         destination = self.download_dir / package.filename
         partial = destination.with_suffix(destination.suffix + ".part")
         with self._lock:
-            if destination.is_file() and self._md5(destination) == package.md5:
+            if destination.is_file() and self._archive_matches(destination, package):
                 _callback(progress_callback, QmtPythonProgress(
                     runtime, "download_verified", destination.stat().st_size,
                     destination.stat().st_size, 100, 0, 0, "download already verified"))
                 return destination
-            existing = partial.stat().st_size if partial.exists() and keep_existing else 0
-            if not existing and not keep_existing and partial.exists():
+            identity_file = partial.with_suffix(partial.suffix + ".identity")
+            identity = package.md5 + ":" + package.sha256
+            previous = identity_file.read_text("ascii") if identity_file.exists() else ""
+            if partial.exists() and (not keep_existing or previous != identity):
                 partial.unlink()
-            headers = {"Accept-Encoding": "identity"}
-            if existing:
-                headers["Range"] = "bytes=%d-" % existing
-            try:
-                response = self._request(package.url, headers=headers)
-            except (OSError, urllib.error.URLError) as exc:
-                raise QmtPythonRuntimeError("cannot download QMT runtime: %s" % exc) from exc
-            status = getattr(response, "status", response.getcode())
-            if status == 206 and existing:
-                mode, done = "ab", existing
-            elif status == 200:
-                mode, done = "wb", 0
+            identity_file.write_text(identity, encoding="ascii")
+            self._check_cancel(cancel_event)
+            snapshot = self._mirror_status()
+            mirrored = self._package_from_mirror(snapshot, runtime)
+            mirror_url = _MIRROR_BASE + "download?" + urlencode(dict(runtime=runtime, md5=package.md5))
+            sources = []
+            if mirrored and mirrored.md5 == package.md5 and not snapshot["busy"]:
+                sources.append(("官网", mirror_url))
+            sources.extend([("讯投", package.url), ("官网（失败回退）", mirror_url + "&force=1")])
+            errors = []
+            for source, url in sources:
+                self._check_cancel(cancel_event)
+                _LOG.info("QMT runtime download source=%s runtime=%s file=%s", source, runtime, package.filename)
+                _callback(progress_callback, QmtPythonProgress(runtime, "download", message="正在通过%s下载运行库" % source))
+                try:
+                    self._download_source(package, url, partial, source, progress_callback, cancel_event)
+                    break
+                except _DownloadSourceError as exc:
+                    errors.append("%s: %s" % (source, exc))
+                    _LOG.warning("QMT runtime source failed source=%s runtime=%s error=%s", source, runtime, exc)
             else:
-                response.close()
-                raise QmtPythonRuntimeError("unexpected QMT download HTTP status: %s" % status)
-            total_header = response.headers.get("Content-Range", "").split("/")[-1]
-            total = int(total_header) if total_header.isdigit() else int(response.headers.get("Content-Length") or 0) + done
-            started = time.monotonic()
-            _callback(progress_callback, QmtPythonProgress(runtime, "download", done, total,
-                                                            (done / total * 100) if total else 0,
-                                                            0, None, "downloading"))
-            try:
-                with response, open(partial, mode) as stream:
-                    while True:
-                        if cancel_event is not None and cancel_event.is_set():
-                            raise QmtPythonRuntimeError("QMT runtime download cancelled")
-                        chunk = response.read(1024 * 1024)
-                        if not chunk:
-                            break
-                        stream.write(chunk)
-                        done += len(chunk)
-                        elapsed = max(time.monotonic() - started, 0.001)
-                        speed = (done - (existing if mode == "ab" else 0)) / elapsed
-                        eta = ((total - done) / speed) if speed > 0 and total else None
-                        _callback(progress_callback, QmtPythonProgress(
-                            runtime, "download", done, total,
-                            (done / total * 100) if total else 0, speed, eta, "downloading"))
-                    stream.flush()
-                    os.fsync(stream.fileno())
-            except QmtPythonRuntimeError:
-                raise
-            except OSError as exc:
-                raise QmtPythonRuntimeError("cannot write QMT runtime download: %s" % exc) from exc
-            actual = self._md5(partial)
-            if actual != package.md5:
-                raise QmtPythonRuntimeError("QMT runtime MD5 mismatch: expected %s, got %s" %
-                                             (package.md5, actual))
+                raise QmtPythonRuntimeError("QMT runtime download failed; " + "; ".join(errors))
             os.replace(partial, destination)
+            identity_file.unlink()
+            size = destination.stat().st_size
             _callback(progress_callback, QmtPythonProgress(runtime, "download_verified",
-                                                            total or destination.stat().st_size,
-                                                            total or destination.stat().st_size,
+                                                            size, size,
                                                             100, 0, 0, "download verified"))
         return destination
 
+    @staticmethod
+    def _check_cancel(event):
+        if event is not None and event.is_set():
+            raise QmtPythonRuntimeError("QMT runtime download cancelled")
+
+    def _archive_matches(self, path, package):
+        if package.size and path.stat().st_size != package.size:
+            return False
+        if self._md5(path) != package.md5:
+            return False
+        if package.sha256:
+            digest = hashlib.sha256()
+            with path.open("rb") as stream:
+                for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+                    digest.update(chunk)
+            return digest.hexdigest() == package.sha256
+        return True
+
+    def _download_source(self, package, url, partial, source, callback, cancel_event):
+        existing = partial.stat().st_size if partial.exists() else 0
+        if existing and self._archive_matches(partial, package):
+            return
+        if package.size and existing >= package.size:
+            partial.unlink()
+            existing = 0
+        headers = {"Accept-Encoding": "identity"}
+        if url.startswith(_MIRROR_BASE):
+            headers[_MIRROR_KEY_HEADER] = _MIRROR_KEY
+        if existing:
+            headers["Range"] = "bytes=%d-" % existing
+        try:
+            response = self._request(url, headers=headers)
+        except (OSError, http.client.HTTPException) as exc:
+            if isinstance(exc, urllib.error.HTTPError) and exc.code == 416:
+                partial.unlink(missing_ok=True)
+            raise _DownloadSourceError("cannot connect: %s" % exc) from exc
+        with response:
+            status = response.getcode()
+            if status == 206 and existing:
+                match = re.fullmatch(r"bytes (\d+)-(\d+)/(\d+)", response.headers.get("Content-Range", ""))
+                if not match or int(match[1]) != existing or int(match[2]) != int(match[3]) - 1:
+                    raise _DownloadSourceError("invalid resume Content-Range")
+                mode, done, total = "ab", existing, int(match[3])
+            elif status == 200:
+                mode, done = "wb", 0
+                try:
+                    total = int(response.headers.get("Content-Length") or package.size)
+                except ValueError as exc:
+                    raise _DownloadSourceError("invalid Content-Length") from exc
+            else:
+                raise _DownloadSourceError("unexpected HTTP status: %s" % status)
+            if package.size and total and total != package.size:
+                raise _DownloadSourceError("package size differs from manifest")
+            started, initial = time.monotonic(), done
+            with partial.open(mode) as stream:
+                while True:
+                    self._check_cancel(cancel_event)
+                    try:
+                        chunk = response.read(1024 * 1024)
+                    except (OSError, http.client.HTTPException) as exc:
+                        raise _DownloadSourceError("connection interrupted: %s" % exc) from exc
+                    if not chunk:
+                        break
+                    stream.write(chunk)  # Local disk failures must not trigger another download.
+                    done += len(chunk)
+                    if total and done > total:
+                        break
+                    speed = (done - initial) / max(time.monotonic() - started, 0.001)
+                    _callback(callback, QmtPythonProgress(
+                        package.runtime, "download", done, total, (done / total * 100) if total else 0,
+                        speed, (total - done) / speed if total and speed else None,
+                        "正在通过%s下载运行库" % source))
+                stream.flush()
+                os.fsync(stream.fileno())
+        self._check_cancel(cancel_event)
+        if total and done < total:
+            raise _DownloadSourceError("download truncated: %d/%d" % (done, total))
+        if not self._archive_matches(partial, package):
+            partial.unlink()
+            raise _DownloadSourceError("QMT runtime MD5/SHA-256 mismatch")
+
     @staticmethod
     def _safe_extract(archive, destination):
         destination = Path(destination).resolve()
@@ -442,7 +564,7 @@ class QmtPythonRuntime:
         runtime = _canonical_runtime(runtime)
         package = package or self.fetch_package(runtime)
         archive = self.download_dir / package.filename
-        if not archive.is_file() or self._md5(archive) != package.md5:
+        if not archive.is_file() or not self._archive_matches(archive, package):
             raise QmtPythonRuntimeError("verified QMT runtime archive is missing")
         with self._lock:
             self.staging_dir.mkdir(parents=True, exist_ok=True)
@@ -655,7 +777,12 @@ class QmtPythonRuntime:
                 if (account_id or self.account_id) else None
             )
         finally:
-            if restart and (not deferred_account_config or was_running):
+            # A managed Web binding can supply a bootstrap callback that starts
+            # QMT, waits for the first login to create Config.xml, and then
+            # performs the final runtime switch/restart.  Keep the standalone
+            # API's old safe behavior (leave a brand-new, unconfigured QMT
+            # stopped) when no callback was supplied.
+            if restart and (not deferred_account_config or was_running or restart_callback):
                 _callback(progress_callback, QmtPythonProgress(runtime, "restarting", message="正在重新启动 QMT"))
                 if restart_callback:
                     restarted = restart_callback()

{cfquant-0.2.68 → cfquant-0.2.71}/cfquant/qmt_strategy_deploy.py

@@ -82,7 +82,7 @@ STATES = {
     "waiting_start": "QMT 已启动，等待托管策略启动及通道连接",
     "waiting_manual_start": "QMT 已启动，自启未开启，请在模型交易中运行托管策略",
     "running": "托管策略已运行",
-    "waiting_account": "未找到此资金账号的 QMT 绑定键，请补充模型账号 Key",
+    "waiting_account": "等待 QMT 登录生成账号绑定键；首次登录后请正常退出 QMT，再重新启动以完成策略部署。仍无法识别时再补充模型账号 Key",
     "configured": "模型已配置，等待下次启动 QMT 生效",
     "disabled": "自动运行已关闭，托管策略已禁用",
     "error": "策略部署失败",
@@ -915,15 +915,16 @@ class QmtStrategyManager:
                 self._save()
 
     def prepare_for_start(self, directory):
-        """Finish this terminal's offline deployment before allowing launch."""
+        """Finish offline deployment, or allow login to supply a missing key."""
         root = qmt_root(directory)
+        waiting_account = []
         with self.lock:
             if self.load_error:
                 raise ValueError(self.load_error)
             jobs = [job for job in self.jobs.values()
                     if os.path.normcase(str(qmt_root(job["root"]))) == os.path.normcase(str(root))]
             if not jobs:
-                return
+                return {"waiting_account": waiting_account}
             if self.process_checker(root):
                 raise RuntimeError("QMT 尚未完全退出，无法完成启动前策略部署")
             try:
@@ -957,6 +958,12 @@ class QmtStrategyManager:
                         job["deploy_retry_after"] = time.time() + min(10.0, 2.0 * count)
                         self._state(job, "error", str(error))
                         raise
+                    if job.get("state") == "waiting_account":
+                        # QMT creates its account authorization on first login.
+                        # Do not fabricate a model key or make login depend on
+                        # the model that can only be prepared after that login.
+                        waiting_account.append(job["account_id"])
+                        continue
                     if (job.get("state") not in ("configured", "waiting_import", "disabled")
                             or (job.get("enabled") and any(
                                 not role.get("model_prepared") or role.get("reimport_required")
@@ -965,6 +972,7 @@ class QmtStrategyManager:
                                            (job.get("message") or job.get("state", "")))
             finally:
                 self._save()
+        return {"waiting_account": waiting_account}
 
     def _advance(self, job):
         root = qmt_root(job["root"])

{cfquant-0.2.68 → cfquant-0.2.71}/cfquant/tests/test_binding_python_runtime_browser.py

@@ -81,6 +81,15 @@ def test_selected_executor_is_applied_through_existing_job_until_restart_finishe
     expect(button).to_be_disabled()
     assert not page.locator("#bindingPythonRuntimeProgressBar").evaluate("node => node.classList.contains('is-done')")
     expect(page.locator("#bindingPythonRuntimeProgressMeta")).to_contain_text("等待切换")
+    for phase in ("extract", "activating", "restarting"):
+        page.evaluate("""phase => bindingPythonRuntimeProgressEvent({
+            meta: {job_id: state.bindingPythonRuntimeJobId, stage: phase},
+            data: {phase, percent: 0, eta: null}
+        })""", phase)
+        expect(page.locator("#bindingPythonRuntimeProgressMeta")).not_to_contain_text("0%")
+        expect(page.locator("#bindingPythonRuntimeProgressMeta")).not_to_contain_text("剩余约 0")
+        assert page.locator("#bindingPythonRuntimeProgressBar").evaluate("node => node.getBoundingClientRect().width > 0")
+        assert page.evaluate("!!state.bindingPythonRuntimeJobId")
     status["binding"].update(selected_runtime="py312", configured_runtime="py312", state="ready")
     status["binding"]["runtimes"]["py312"]["installed"] = True
     page.evaluate("""bindingPythonRuntimeProgressEvent({
@@ -95,6 +104,45 @@ def test_selected_executor_is_applied_through_existing_job_until_restart_finishe
     assert not errors
 
 
+def test_lost_job_record_releases_busy_state_without_claiming_success(page, frontend_url):
+    errors = open_runtime(page, frontend_url, runtime_status(config_exists=False))
+    page.route("**/api/qmt/python-runtime/download", lambda route: route.fulfill(json={"ok": True, "data": {"state": "queued"}}))
+    page.route("**/api/qmt/python-runtime/jobs?*", lambda route: route.fulfill(status=404, json={"ok": False, "error": "job not found"}))
+    page.locator("#bindingPythonRuntimeDownloadBtn").click()
+    page.wait_for_function("!state.bindingPythonRuntimeJobId && state.bindingPythonRuntimeProgress?.meta?.stage === 'error'")
+    expect(page.locator("#bindingPythonRuntimeProgressText")).to_contain_text("记录已失效")
+    expect(page.locator("#bindingPythonRuntimeDownloadBtn")).to_be_enabled()
+    assert not errors
+
+
+def test_save_rechecks_completed_runtime_job_even_without_progress_notification(page, frontend_url):
+    errors = open_runtime(page, frontend_url, runtime_status(config_exists=False))
+    page.route("**/api/qmt/python-runtime/jobs?*", lambda route: route.fulfill(json={
+        "ok": True, "data": {"state": "done", "result": {"account_config_required": True}}}))
+    saved = []
+    def save(route):
+        body = route.request.post_data_json
+        saved.append(body)
+        row = dict(body, account_key="TEST_ONLY|STOCK|test", bridge_id="test")
+        route.fulfill(json={"ok": True, "data": {
+            "account": row, "account_configs": {row["account_key"]: row}, "account_pairs": {},
+            "bridges": {"test": {"name": "Test"}}, "qmt_strategy_deploy": {"enabled": False},
+            "qmt_auto_login": {"enabled": False}}})
+    page.route("**/api/account-config", save)
+    page.locator("#bindingQmtAutoLogin").uncheck()
+    page.evaluate("""() => {
+        fillQmtStrategySettings('binding', {enabled: false});
+        state.bindingPythonRuntimeJobId = 'missed-done';
+        state.bindingPythonRuntimeJobContext = bindingPythonRuntimeContextKey();
+        state.bindingPythonRuntimeJobRuntime = 'py36';
+    }""")
+    page.locator('#bindingForm [type="submit"]').click()
+    expect(page.locator("#bindingDialogOverlay")).not_to_be_visible()
+    assert len(saved) == 1
+    assert not page.evaluate("state.bindingPythonRuntimeJobId")
+    assert not errors
+
+
 def test_directory_change_invalidates_options_and_discards_late_response(page, frontend_url):
     errors = open_runtime(page, frontend_url, runtime_status())
     pending = []
@@ -129,3 +177,28 @@ def test_missing_account_config_shows_capabilities_but_requires_login(page, fron
     page.wait_for_function("state.bindingPythonRuntimeJobId")
     assert submitted[0]["allow_missing_account_config"] is True
     assert not errors
+
+
+@pytest.mark.parametrize("socket_throws", [False, True], ids=["socket-disconnected", "socket-unavailable"])
+def test_poll_completion_before_first_login_unlocks_binding(page, frontend_url, socket_throws):
+    status = runtime_status(config_exists=False)
+    errors = open_runtime(page, frontend_url, status)
+    submitted = []
+    page.route("**/api/qmt/python-runtime/download", lambda route: (
+        submitted.append(route.request.post_data_json),
+        route.fulfill(json={"ok": True, "data": {"state": "queued"}})))
+    # The last progress event is not a terminal event. HTTP state/result must
+    # recover completion even if the WebSocket notification never arrived.
+    page.route("**/api/qmt/python-runtime/jobs?*", lambda route: route.fulfill(json={
+        "ok": True, "data": {"state": "done", "progress": {"phase": "installed", "percent": 100},
+        "result": {"account_config_required": True, "restarted": None}}}))
+    if socket_throws:
+        page.evaluate("() => { window.WebSocket = function() { throw new Error('WebSocket unavailable'); }; }")
+    page.locator("#bindingPythonRuntimeDownloadBtn").click()
+    page.wait_for_function("state.bindingPythonRuntimeJobId === '' && state.bindingPythonRuntimeProgress?.meta?.stage === 'done'")
+    assert len(submitted) == 1
+    assert page.evaluate("state.bindingPythonRuntimeDeferred")
+    assert not page.evaluate("state.bindingPythonRuntimeChoiceDirty")
+    expect(page.locator("#bindingPythonRuntimeProgressMeta")).to_contain_text("100%")
+    expect(page.locator("#bindingPythonRuntimeProgressText")).to_contain_text("登录")
+    assert not errors

{cfquant-0.2.68 → cfquant-0.2.71}/cfquant/tests/test_qmt_auto_login_integration.py

@@ -8,6 +8,7 @@ from types import SimpleNamespace
 import pytest
 
 from cfquant.tests.test_qmt_strategy_web import web_config, login_credentials
+from cfquant.tests.test_qmt_strategy_deploy import deployment
 from cfquant.tests.test_management import service
 from cfquant.qmt_credentials import QmtCredentialStore
 from cfquant.trading_calendar import is_trading_day
@@ -286,6 +287,37 @@ def test_failed_offline_deployment_blocks_launch_and_login(web_config, monkeypat
     assert not result["started"] and not result["configured"]
 
 
+@pytest.mark.parametrize("auto_fill", [True, False])
+@pytest.mark.parametrize("restart", [True, False])
+def test_first_login_without_model_key_launches_and_reports_pending_deployment(
+        web_config, deployment, monkeypatch, tmp_path, auto_fill, restart):
+    web, _ = web_config
+    manager, row, infos, running, root = deployment
+    (root / "config" / "indexUserConfig.xml").write_text(
+        '<ICUserConfigFile><FormulaCatalog/><strategyTrade/></ICUserConfigFile>', encoding="utf-8")
+    manager.configure(row, infos)
+    row["qmt_auto_login"] = {"enabled": True, "auto_fill_credentials": auto_fill, "auto_update": True}
+    monkeypatch.setenv("CFQUANT_QMT_AUTO_START", "saved")
+    monkeypatch.setattr(web, "QMT_AUTO_LOGIN_STATE_FILE", str(tmp_path / "sessions.json"))
+    monkeypatch.setattr(web, "QMT_COMPONENT_JOBS", {})
+    monkeypatch.setattr(web, "QMT_STRATEGIES", manager)
+    paths = {"bin_dir": str(root / "bin.x64"), "exe_path": "fixture.exe"}
+    monkeypatch.setattr(web, "_qmt_auto_login_paths", lambda _: paths)
+    monkeypatch.setattr(web, "_qmt_component_login_preflight", lambda *a: None)
+    monkeypatch.setattr(web, "_qmt_auto_login_processes", lambda *a, **k: [])
+    monkeypatch.setattr(web, "_qmt_auto_login_stop_xtitclient", lambda *a, **k: {})
+    calls = []
+    monkeypatch.setattr(web, "_qmt_auto_login_start_xtitclient", lambda *a, **k: calls.append("start") or {"pid": 456})
+    monkeypatch.setattr(web, "_qmt_queue_component_login", lambda *a: calls.append("login"))
+    result = web.qmt_auto_login_apply_for_account(row, restart=restart)
+    assert result["configured"] and not result.get("error")
+    assert result["strategy_deploy_deferred"]
+    assert calls == ["start", "login"]
+    session = web._qmt_auto_login_saved_session(row)
+    assert session["strategy_deploy_deferred"] and not session["error"]
+    assert "首次登录" in session["message"]
+
+
 def test_worker_records_success_and_supplies_saved_password_only_on_request(web_config, monkeypatch, tmp_path):
     import cfquant.qmt_component_login as component
     web, config = web_config