From 75ee8bd33a96995b36b5e45bbf6ab52ed894290f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Thu, 5 Nov 2026 18:18:13 +0800 Subject: [PATCH] fix: handle owned CAD error dialogs and unblock verified shutdown --- .gitea/workflows/ci.yml | 1 + docs/testing/2026-11-05-cad-dialog-release.md | 28 ++ .../trial_task_center/batch_runtime.py | 17 +- .../trial_task_center/cad_dialogs.py | 128 ++++++++ .../trial_task_center/diagnostics_bundle.py | 3 + .../trial_task_center/isolated_cad.py | 84 ++++- .../trial_task_center/isolated_desktop.py | 13 + .../trial_task_center/stop_control.py | 10 +- tests/v1_1/test_cad_dialogs.py | 287 ++++++++++++++++++ 9 files changed, 560 insertions(+), 11 deletions(-) create mode 100644 docs/testing/2026-11-05-cad-dialog-release.md create mode 100644 src/dx_productivity/trial_task_center/cad_dialogs.py create mode 100644 tests/v1_1/test_cad_dialogs.py diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index 90275e1..88721da 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -41,6 +41,7 @@ jobs: tests/packaging/test_self_extracting_release.py tests/trial_task_center/test_bom_template_contract.py tests/trial_task_center/test_bom_import_review.py + tests/v1_1/test_cad_dialogs.py --junitxml=build/ci-results.xml --tb=short - name: Windows release scope run: | diff --git a/docs/testing/2026-11-05-cad-dialog-release.md b/docs/testing/2026-11-05-cad-dialog-release.md new file mode 100644 index 0000000..8c2fd35 --- /dev/null +++ b/docs/testing/2026-11-05-cad-dialog-release.md @@ -0,0 +1,28 @@ +# CAD 弹窗与资源释放补丁 + +基于 `08ddf4c`,参考 `docs/reviews/2026-10-19-native-snapshot.md`:曾因 CAD 预定义 Vd 枚举被脚本重复声明,弹出编译错误框;定向确认错误框后 CAD 才能正常退出。该次异常记录仍保持 `clean=false`。 + +## 实际行为 + +- 从私有桌面枚举自有且仍存活的 CAD PID,只读取该进程的可见标准对话框。使用有超时的窗口文本读取,不切换输入桌面、不发送全局鼠标键盘输入。采样限制为每次约 0.5 秒、最多 8 个对话框、最多 64 个子控件;不完整快照不能授权点击。 +- 目前自动确认范围仅为已知 VBScript 编译错误、匹配标题、单一且可用的“确定/OK”按钮。先原子保存标题、正文、按钮、句柄、PID、会话标识和阶段;发送消息前重新枚举并比对完整快照,避免旧 HWND 被复用。每个快照最多请求一次确认。 +- 保存、覆盖、许可、其他未知提示均记录为 `manual_required`,不自动点击。证据写入失败也不能授权点击。 +- 启动、工程关闭检查点、Quit 和 CAD 退出等待均检查弹窗。会话就绪后另有不调用 COM 的独立监测线程,业务线程被 COM 模态等待阻塞时仍能处理上述已知错误框;关闭前停止该线程。 +- 生产 `BatchCadRuntime` 的桌面租约同步接入监测与动作,限定当前 generation 及本 lease 的存活进程。旧代次和其他 PID 不能继承该权限。 +- 编译错误即使已确认关闭,也保持失败;证据最多 100 条,达到上限仍锁存致命错误,不点击无法记录的新对话框。 +- Quit 超时后保留原进程与保护标记。人工处理弹窗后,只有 CAD 和原 Quit helper 都已实际退出,等待才自动结束;不重复 Quit、不自动重做替换、不把超时后的结果标记为正常成功。 +- `cad-dialogs-.json` 和会话概要进入现有脱敏诊断导出,包括批次 `generation-N` 子目录。证据以文本和控件信息为主,本轮没有增加截图或新的界面按钮。 + +## 定向验证 + +1. 修改前现有 `test_isolated_cad.py`:**34 passed**。 +2. 新增弹窗测试先复现缺失逻辑;退出阶段集成用例先复现“错误框未处理”和“进程已退出仍必须点强制结束”。随后修复并通过。 +3. 弹窗、隔离会话、用户停止、诊断导出的阶段性定向验证:**79 passed**。 +4. 生产批次租约、证据上限修正后的弹窗与 batch runtime 定向验证:**55 passed**。 +5. 最终 `python -m pytest -q tests/v1_1/test_cad_dialogs.py --tb=short`:**21 passed**,包括外国 PID、旧 generation、控件句柄复用、写盘失败、重复点击防护、启动致命错误、人工解除后退出、记录上限、两种目录诊断导出等独立用例。 + +上述范围重叠,不累加。21 项中包含 3 个真实 Win32 私有桌面 MessageBox 样本:已知脚本错误可关闭、保存提示保持不动、真实 BatchCadRuntime 租约下主线程等待时由后台监测解除已知错误框。样本使用独立 Python 进程,未启动真实 CAD,也未打开或修改工程。 + +独立只读复核发现证据上限可能漏记致命错误,已修正并以先失败后通过的用例验证;增量复核通过。现有保存证明、实例身份、强制结束授权与不确定状态保护保持生效。 + +本轮未执行真实 DxDesigner 换料、PCB、安装包构建或整库重复回归。Linux CI 加入本文件的可移植用例;原生 Win32 样本在非 Windows 上跳过,本机结果不能代替远端 Linux 检查结果。 diff --git a/src/dx_productivity/trial_task_center/batch_runtime.py b/src/dx_productivity/trial_task_center/batch_runtime.py index 4a25f0c..63d93f6 100644 --- a/src/dx_productivity/trial_task_center/batch_runtime.py +++ b/src/dx_productivity/trial_task_center/batch_runtime.py @@ -61,6 +61,20 @@ class _DesktopLease: self.owner._track(process) return process + def inspect_dialogs(self, pid): + if self.desktop is None or self.generation != self.owner.generation: + return () + inspect = getattr(self.desktop, 'inspect_dialogs', None) + if inspect is None or not any(process.pid == pid and process.poll() is None for process in self.processes): + return () + return inspect(pid) + + def acknowledge_dialog(self, dialog): + if (self.desktop is None or self.generation != self.owner.generation or + not any(process.pid == dialog['pid'] and process.poll() is None for process in self.processes)): + raise WorkerMonitorError('stale or unavailable batch dialog owner') + self.desktop.acknowledge_dialog(dialog) + def close(self): errors, remaining, records = [], [], [] for process in reversed(self.processes): @@ -435,7 +449,8 @@ class BatchCadRuntime: self.record['cad_shutdown'] = {key: cad_record[key] for key in ( 'state', 'clean', 'cad_exit_code', 'quit_helper_exit_code', 'cleanup_errors', 'shutdown_seconds', 'orderly_shutdown', 'diagnostic_errors', 'forced_termination', - 'forced_root_termination', 'forced_descendant_pids', 'termination_reason') if key in cad_record} + 'forced_root_termination', 'forced_descendant_pids', 'termination_reason', + 'dialog_supervision') if key in cad_record} if self.desktop is not None: try: self.desktop.close() diff --git a/src/dx_productivity/trial_task_center/cad_dialogs.py b/src/dx_productivity/trial_task_center/cad_dialogs.py new file mode 100644 index 0000000..fb9b779 --- /dev/null +++ b/src/dx_productivity/trial_task_center/cad_dialogs.py @@ -0,0 +1,128 @@ +"""Bounded, COM-independent observations of modal dialogs on an owned desktop.""" +import ctypes +from ctypes import wintypes +import json +import time +from threading import RLock + +from .batch_resources import write_record + + +def _text(handle): + user = ctypes.WinDLL('user32', use_last_error=True) + send = user.SendMessageTimeoutW + send.argtypes = [wintypes.HWND, wintypes.UINT, wintypes.WPARAM, wintypes.LPARAM, + wintypes.UINT, wintypes.UINT, ctypes.POINTER(ctypes.c_size_t)] + send.restype = wintypes.LPARAM + buffer, result = ctypes.create_unicode_buffer(2048), ctypes.c_size_t() + if not send(handle, 0x000D, len(buffer), ctypes.addressof(buffer), 0x0002, 50, ctypes.byref(result)): + raise OSError('dialog text unavailable or unresponsive') + if result.value >= len(buffer) - 1: + raise OSError('dialog text exceeds observation limit') + return buffer.value + + +def inspect_owned_dialogs(api, desktop_name, pid): + import win32gui + import win32process + + result = [] + deadline = time.monotonic() + .5 + for window in api._desktop_windows(desktop_name): + if window['pid'] != pid or window['class'] != '#32770' or not win32gui.IsWindowVisible(window['hwnd']): + continue + handle = window['hwnd'] + row = dict(window, title='', text='', buttons=[], complete=True) + labels, children = [], [] + try: + row['title'] = _text(handle) + win32gui.EnumChildWindows(handle, lambda child, _: children.append(child), None) + for child in children: + if time.monotonic() >= deadline or len(children) > 64: + row['complete'] = False + break + if not win32gui.IsWindowVisible(child): + continue + if win32process.GetWindowThreadProcessId(child)[1] != pid: + row['complete'] = False + continue + text = _text(child) + if win32gui.GetClassName(child).casefold() == 'button': + row['buttons'].append({'hwnd': int(child), 'id': win32gui.GetDlgCtrlID(child), + 'text': text, 'enabled': bool(win32gui.IsWindowEnabled(child))}) + elif text: + labels.append(text) + except Exception as error: + row.update(complete=False, read_error=str(error)) + row['text'] = '\n'.join(labels)[:8192] + result.append(row) + if len(result) >= 8 or time.monotonic() >= deadline: + break + return tuple(result) + + +def acknowledge_owned_dialog(api, desktop_name, pid, expected): + import win32gui + + # Re-enumerate the private desktop and compare the complete fingerprint; + # a recycled HWND or changed prompt cannot inherit the earlier decision. + current = next((row for row in inspect_owned_dialogs(api, desktop_name, pid) + if row == expected), None) + if current is None or not _script_error(current): + raise OSError('dialog changed before acknowledgement') + win32gui.PostMessage(current['buttons'][0]['hwnd'], 0x00F5, 0, 0) # BM_CLICK, no global input + + +def _script_error(row): + title = row['title'].strip().casefold() + body = row['text'].casefold() + buttons = row['buttons'] + return (row.get('complete') is True and title in {'script error', 'microsoft vbscript', 'dxdesigner', '脚本错误'} + and any(marker in body for marker in ('microsoft vbscript compilation error', 'microsoft vbscript 编译器错误')) + and len(buttons) == 1 and buttons[0]['id'] in {1, 2} and buttons[0]['enabled'] + and buttons[0]['text'].replace('&', '').strip().casefold() in {'ok', '确定', '确定(o)'}) + + +class CadDialogGuard: + def __init__(self, desktop, process, evidence_path, token): + self.desktop, self.process = desktop, process + self.evidence_path, self.token = evidence_path, token + self.records, self.seen = [], set() + self.blocking = [] + self.failure = '' + self._lock = RLock() + + def poll(self, phase): + with self._lock: + self._poll(phase) + + def _poll(self, phase): + inspect = getattr(self.desktop, 'inspect_dialogs', None) + if inspect is None or self.process.poll() is not None: + self.blocking = [] + return + rows = [row for row in inspect(self.process.pid) + if row['pid'] == self.process.pid and row['class'] == '#32770'] + self.blocking = [row['title'] or '未命名弹窗' for row in rows] + for row in rows: + key = json.dumps(row, ensure_ascii=False, sort_keys=True) + action = 'acknowledge_script_error' if _script_error(row) else 'manual_required' + if action == 'acknowledge_script_error': + self.failure = 'CAD script error: ' + row['text'][:1000] + if key in self.seen or len(self.records) >= 100: + continue + record = dict(row, phase=phase, action=action, observed_at=time.time()) + self.records.append(record) + self._save() # No automatic button action without durable evidence. + self.seen.add(key) + if action == 'acknowledge_script_error': + self.desktop.acknowledge_dialog(row) + + def _save(self): + write_record(self.evidence_path, {'version': 1, 'session_token': self.token, + 'cad_pid': self.process.pid, 'dialogs': self.records}) + + def summary(self): + with self._lock: + return {'evidence_path': str(self.evidence_path), 'dialogs_seen': len(self.records), + 'blocked': bool(self.blocking), 'blocking_titles': list(self.blocking), 'error': self.failure} diff --git a/src/dx_productivity/trial_task_center/diagnostics_bundle.py b/src/dx_productivity/trial_task_center/diagnostics_bundle.py index b454996..5c2e1b8 100644 --- a/src/dx_productivity/trial_task_center/diagnostics_bundle.py +++ b/src/dx_productivity/trial_task_center/diagnostics_bundle.py @@ -52,6 +52,9 @@ def _scrub_json(value): def _allowed(parts): + if re.fullmatch(r'cad-dialogs-[a-f0-9]{32}\.json', parts[-1]): + return ((len(parts) == 4 and parts[0] == 'batch-resources' and re.fullmatch(r'generation-\d+', parts[2])) or + any(value in parts for value in ('quick-run', 'quickrun', 'quick-run-history'))) if (len(parts) == 5 and parts[0] == 'tasks' and parts[2] == 'quick-run-history' and re.fullmatch(r'bom-import-[A-Za-z0-9-]+', parts[3])): return parts[-1] == 'source-map.json' diff --git a/src/dx_productivity/trial_task_center/isolated_cad.py b/src/dx_productivity/trial_task_center/isolated_cad.py index 2313635..bf7f4f8 100644 --- a/src/dx_productivity/trial_task_center/isolated_cad.py +++ b/src/dx_productivity/trial_task_center/isolated_cad.py @@ -7,12 +7,14 @@ import subprocess import sys import time from traceback import clear_frames +from threading import Event, Thread from uuid import uuid4 from .cad_identity import CadBinding, current_desktop_name, verify_application, project_file_path from .isolated_desktop import PrivateDesktop from .worker_monitor import WorkerMonitorError from .path_access import internal_path, canonical_path, retry_sharing_violation +from .cad_dialogs import CadDialogGuard class PrivateCadStartupError(WorkerMonitorError): @@ -98,6 +100,10 @@ class IsolatedCadSession: self.abort_event = abort_event self.stop_control = stop_control self.record = {'desktop': self.desktop.name, 'token': self.token, 'state': 'starting'} + self._dialogs = None + self._dialog_monitor_error = '' + self._dialog_stop = Event() + self._dialog_thread = None def _record(self, **values): self.record.update(values) @@ -118,6 +124,8 @@ class IsolatedCadSession: self._check_abort() self.desktop.__enter__() self.cad = self.desktop.start_process((str(_designer_executable()),)) + self._dialogs = CadDialogGuard(self.desktop, self.cad, + self.root / ('cad-dialogs-' + self.token + '.json'), self.token) self._record(cad_pid=self.cad.pid) bootstrap = self.root / ('cad-binding-' + self.token + '.json') environment = dict(os.environ, DXPART_DESKTOP=self.desktop.name, @@ -129,16 +137,18 @@ class IsolatedCadSession: deadline = time.monotonic() + 120 while probe.poll() is None: self._check_abort() + self._poll_dialogs('startup') cad_exit = self.cad.poll() if cad_exit is not None: raise WorkerMonitorError(f'owned private CAD exited during startup: exit code {cad_exit}') if time.monotonic() >= deadline: - raise WorkerMonitorError('private CAD bootstrap timed out') + raise WorkerMonitorError('private CAD bootstrap timed out' + self._dialog_description()) time.sleep(0.05) code = probe.poll() if code: failure_type = CadIdentityConflict if code == PRIVATE_CAD_IDENTITY_EXIT_CODE else WorkerMonitorError raise failure_type('private CAD startup failed: ' + probe.stderr.read().decode('utf-8', errors='replace')) + self._poll_dialogs('startup') finally: probe.close() try: @@ -151,8 +161,10 @@ class IsolatedCadSession: raise CadIdentityConflict('private CAD bootstrap identity evidence is invalid: ' + str(failure)) from failure self.binding = binding self._record(state='ready', guid=self.binding.guid, startup_seconds=time.monotonic() - self.started) + self._start_dialog_monitor() return self except Exception as error: + self._stop_dialog_monitor() try: self.desktop.close() except Exception as failure: @@ -167,6 +179,54 @@ class IsolatedCadSession: if self.abort_event is not None and self.abort_event.is_set(): raise WorkerMonitorError('private CAD startup was cancelled before execution') + def _start_dialog_monitor(self): + if getattr(self.desktop, 'inspect_dialogs', None) is None: + return + def monitor(): + while not self._dialog_stop.wait(.2): + self._poll_dialogs('running') + self._dialog_thread = Thread(target=monitor, name='owned-cad-dialogs', daemon=True) + self._dialog_thread.start() + + def _stop_dialog_monitor(self): + self._dialog_stop.set() + if self._dialog_thread is not None: + self._dialog_thread.join(3) + if self._dialog_thread.is_alive(): + self._dialog_monitor_error = 'CAD dialog monitor did not stop within its budget' + + def _poll_dialogs(self, phase): + if self._dialogs is None: + return + try: + self._dialogs.poll(phase) + except Exception as error: + self._dialog_monitor_error = str(error) + self.record['dialog_supervision'] = dict(self._dialogs.summary(), monitor_error=self._dialog_monitor_error) + if phase in {'startup', 'checkpoint'} and self._dialogs.failure: + raise WorkerMonitorError(self._dialogs.failure + self._dialog_description()) + + def _dialog_description(self): + if self._dialogs is None or not self._dialogs.records: + return '' + summary = self._dialogs.summary() + titles = ' / '.join(summary['blocking_titles']) or '已记录弹窗' + return f';CAD 弹窗:{titles};详情:{summary["evidence_path"]}' + + def _wait_process(self, process, timeout, phase): + if getattr(self.desktop, 'inspect_dialogs', None) is None: + return process.wait(timeout=timeout) + deadline = time.monotonic() + timeout + while True: + self._poll_dialogs(phase) + remaining = deadline - time.monotonic() + if remaining <= 0: + raise subprocess.TimeoutExpired(getattr(process, 'args', phase), timeout) + try: + return process.wait(timeout=min(.25, remaining)) + except subprocess.TimeoutExpired: + pass + def start_worker(self, command, *, extra_environment=None, **options): if self.binding is None or self.cad.poll() is not None: raise WorkerMonitorError('owned private CAD is unavailable') @@ -187,7 +247,7 @@ class IsolatedCadSession: process = self.start_worker(_helper_command('checkpoint', evidence, self.cad.pid), stdout=subprocess.PIPE, stderr=subprocess.PIPE) try: - code = process.wait(timeout=20) + code = self._wait_process(process, 20, 'checkpoint') if code: failure_type = CadIdentityConflict if code == PRIVATE_CAD_IDENTITY_EXIT_CODE else WorkerMonitorError raise failure_type('project close checkpoint failed: ' + @@ -206,6 +266,7 @@ class IsolatedCadSession: return result def __exit__(self, error_type, error, traceback): + self._stop_dialog_monitor() closing_started = time.monotonic() cleanup_errors = [] diagnostic_errors = [] @@ -250,20 +311,25 @@ class IsolatedCadSession: if self.cad is not None and self.cad.poll() is not None: raise WorkerMonitorError('owned CAD exited before the authorized quit request') if self.cad is not None and self.binding is not None: + self._poll_dialogs('closing') closing = self.desktop.start_process(_helper_command('quit', self.root / 'private-desktop.json', self.cad.pid), env=_child_environment(self.binding.environment()), stdout=subprocess.PIPE, stderr=subprocess.PIPE) - quit_code = closing.wait(timeout=20) + quit_code = self._wait_process(closing, 20, 'closing') exit_codes['quit_helper_exit_code'] = quit_code if quit_code: raise WorkerMonitorError('owned CAD refused orderly exit: ' + closing.stderr.read().decode('utf-8', errors='replace')) - cad_code = self.cad.wait(timeout=15) + cad_code = self._wait_process(self.cad, 15, 'closing') exit_codes['cad_exit_code'] = cad_code if cad_code != 0: raise WorkerMonitorError('owned CAD returned a nonzero exit code after quit') self.record['orderly_shutdown'] = True except Exception as failure: - remember('orderly_shutdown', failure) + remember('orderly_shutdown', WorkerMonitorError(str(failure) + self._dialog_description()) + if self._dialog_description() else failure) finally: + if self._dialogs is not None and (self._dialogs.failure or self._dialog_monitor_error): + remember('cad_dialog', WorkerMonitorError( + (self._dialogs.failure or self._dialog_monitor_error) + self._dialog_description())) if error is not None or failures: # Evidence failure must never prevent the identity-checked Quit # above or release of the handles we own below. @@ -277,10 +343,14 @@ class IsolatedCadSession: if cad_running: # A refused/timed-out Quit may still be saving or closing. # Keep both CAD and its helper owned and alive until the - # interactive caller confirms force, including ordinary stop. + # caller confirms force or both retained processes exit. from .stop_control import wait_for_resolution + def owned_processes_exited(): + self._poll_dialogs('closing') + return self.cad.poll() is not None and (closing is None or closing.poll() is not None) try: - wait_for_resolution(self.stop_control, self.root, failure_message()) + wait_for_resolution(self.stop_control, self.root, failure_message(), + resolved=owned_processes_exited) except WorkerMonitorError as failure: force_event = getattr(self.stop_control, 'force_event', None) if force_event is None or not force_event.is_set(): diff --git a/src/dx_productivity/trial_task_center/isolated_desktop.py b/src/dx_productivity/trial_task_center/isolated_desktop.py index db4fcb4..56055ee 100644 --- a/src/dx_productivity/trial_task_center/isolated_desktop.py +++ b/src/dx_productivity/trial_task_center/isolated_desktop.py @@ -536,6 +536,19 @@ class PrivateDesktop: def __exit__(self, *_exc: object) -> None: self.close() + def inspect_dialogs(self, pid): + from .cad_dialogs import inspect_owned_dialogs + if self._handle is None or not any(process.pid == pid and process.poll() is None for process in self._processes): + return () + return inspect_owned_dialogs(self._api, self.name, pid) + + def acknowledge_dialog(self, dialog): + from .cad_dialogs import acknowledge_owned_dialog + pid = dialog['pid'] + if self._handle is None or not any(process.pid == pid and process.poll() is None for process in self._processes): + raise TaskCenterError('private_desktop', 'dialog process is no longer owned and alive') + acknowledge_owned_dialog(self._api, self.name, pid, dialog) + def _create(self) -> None: if os.name != "nt" and self._api is None: return diff --git a/src/dx_productivity/trial_task_center/stop_control.py b/src/dx_productivity/trial_task_center/stop_control.py index 98427d9..b32bc08 100644 --- a/src/dx_productivity/trial_task_center/stop_control.py +++ b/src/dx_productivity/trial_task_center/stop_control.py @@ -42,11 +42,12 @@ def protect_interruption(root, reason): os.fsync(stream.fileno()) -def wait_for_resolution(control, root, error): - """Interactive owners retain a possibly changed project until explicit force. +def wait_for_resolution(control, root, error, *, resolved=None): + """Retain uncertain work until explicit force or an owned-exit proof. The GUI-side supervisor can also terminate its own Job after durable force - evidence. Ordinary cancellation never releases this wait. + evidence. Ordinary cancellation never releases this wait; an optional + observer may prove all retained processes exited without clearing uncertainty. """ if not isinstance(control, StopControl): return @@ -71,6 +72,9 @@ def wait_for_resolution(control, root, error): resolution_error=str(error), stop_requested=True, safe_stop=False) _publish_progress(root / 'worker-progress.json', record) while True: + if resolved is not None and resolved(): + control.waiting_for_resolution = False + return if control.force_event.wait(.1): try: protect() diff --git a/tests/v1_1/test_cad_dialogs.py b/tests/v1_1/test_cad_dialogs.py new file mode 100644 index 0000000..55e08ee --- /dev/null +++ b/tests/v1_1/test_cad_dialogs.py @@ -0,0 +1,287 @@ +"""Owned modal-dialog samples; no CAD, project modifications, or PCB.""" +import json +import os +import subprocess +from types import SimpleNamespace + +import pytest + + +def script_dialog(**changes): + row = {'hwnd': 10, 'pid': 123, 'class': '#32770', 'title': 'Script Error', + 'text': 'Microsoft VBScript compilation error\nName redefined: VdFoo', 'complete': True, + 'buttons': [{'hwnd': 11, 'id': 1, 'text': 'OK', 'enabled': True}]} + return dict(row, **changes) + + +def test_known_script_error_is_recorded_before_acknowledgement_and_remains_failure(tmp_path): + from dx_productivity.trial_task_center.cad_dialogs import CadDialogGuard + path = tmp_path / 'cad-dialogs.json' + rows, acknowledged = [script_dialog()], [] + def acknowledge(row): + assert json.loads(path.read_text(encoding='utf-8'))['dialogs'][0]['action'] == 'acknowledge_script_error' + acknowledged.append(row['hwnd']) + rows.clear() + desktop = SimpleNamespace(inspect_dialogs=lambda pid: tuple(rows), acknowledge_dialog=acknowledge) + guard = CadDialogGuard(desktop, SimpleNamespace(pid=123, poll=lambda: None), path, 'session') + guard.poll('closing') + guard.poll('closing') + assert acknowledged == [10] + assert 'compilation error' in guard.failure + assert guard.summary()['evidence_path'] == str(path) + + +@pytest.mark.parametrize('row', [ + script_dialog(pid=999), + script_dialog(title='Save Changes', text='Save changes to Board.prj?'), + script_dialog(title='License Error', text='License unavailable'), + script_dialog(title='DxDesigner', text='Unknown warning'), + script_dialog(complete=False), + script_dialog(buttons=[{'hwnd': 11, 'id': 1, 'text': 'OK', 'enabled': True}, + {'hwnd': 12, 'id': 2, 'text': 'Cancel', 'enabled': True}]), +]) +def test_other_prompts_and_foreign_windows_are_never_automatically_clicked(tmp_path, row): + from dx_productivity.trial_task_center.cad_dialogs import CadDialogGuard + path = tmp_path / 'cad-dialogs.json' + desktop = SimpleNamespace(inspect_dialogs=lambda pid: (row,), + acknowledge_dialog=lambda _: pytest.fail('unsafe/foreign prompt clicked')) + guard = CadDialogGuard(desktop, SimpleNamespace(pid=123, poll=lambda: None), path, 'session') + guard.poll('startup') + if row['pid'] == 123: + assert guard.summary()['blocked'] + assert json.loads(path.read_text(encoding='utf-8'))['dialogs'][0]['action'] == 'manual_required' + else: + assert not path.exists() + + +def test_evidence_failure_prevents_automatic_acknowledgement(tmp_path, monkeypatch): + from dx_productivity.trial_task_center import cad_dialogs + desktop = SimpleNamespace(inspect_dialogs=lambda pid: (script_dialog(),), + acknowledge_dialog=lambda _: pytest.fail('unrecorded prompt clicked')) + guard = cad_dialogs.CadDialogGuard(desktop, SimpleNamespace(pid=123, poll=lambda: None), + tmp_path / 'cad-dialogs.json', 'session') + monkeypatch.setattr(cad_dialogs, 'write_record', lambda *_: (_ for _ in ()).throw(OSError('disk unavailable'))) + with pytest.raises(OSError, match='disk unavailable'): + guard.poll('closing') + + +def test_dialogs_are_not_repeatedly_clicked_when_they_do_not_close(tmp_path): + from dx_productivity.trial_task_center.cad_dialogs import CadDialogGuard + acknowledged = [] + desktop = SimpleNamespace(inspect_dialogs=lambda pid: (script_dialog(),), + acknowledge_dialog=lambda row: acknowledged.append(row['hwnd'])) + guard = CadDialogGuard(desktop, SimpleNamespace(pid=123, poll=lambda: None), + tmp_path / 'cad-dialogs.json', 'session') + for _ in range(5): + guard.poll('closing') + assert acknowledged == [10] + assert guard.summary()['blocked'] + + +def test_guard_ignores_a_completed_process(tmp_path): + from dx_productivity.trial_task_center.cad_dialogs import CadDialogGuard + desktop = SimpleNamespace(inspect_dialogs=lambda pid: pytest.fail('exited PID inspected')) + guard = CadDialogGuard(desktop, SimpleNamespace(pid=123, poll=lambda: 0), + tmp_path / 'cad-dialogs.json', 'session') + guard.poll('closing') + + +def test_evidence_limit_still_latches_fatal_error_without_unrecorded_click(tmp_path): + from dx_productivity.trial_task_center.cad_dialogs import CadDialogGuard + rows = [script_dialog(title='Unknown', text='initial')] + desktop = SimpleNamespace(inspect_dialogs=lambda pid: tuple(rows), + acknowledge_dialog=lambda row: pytest.fail('evidence limit cannot authorize another click')) + guard = CadDialogGuard(desktop, SimpleNamespace(pid=123, poll=lambda: None), + tmp_path / 'cad-dialogs.json', 'session') + for number in range(100): + rows[0] = script_dialog(title='Unknown', text=str(number)) + guard.poll('running') + rows[0] = script_dialog() + guard.poll('closing') + assert guard.failure and len(guard.records) == 100 + + +def test_batch_desktop_lease_delegates_dialogs_only_for_its_current_owned_process(tmp_path): + from dx_productivity.trial_task_center.batch_runtime import _DesktopLease + from dx_productivity.trial_task_center.worker_monitor import WorkerMonitorError + calls = [] + desktop = SimpleNamespace(inspect_dialogs=lambda pid: calls.append(pid) or (script_dialog(),), + acknowledge_dialog=lambda row: calls.append('ack')) + owner = SimpleNamespace(generation=1) + lease = _DesktopLease(owner, tmp_path) + lease.desktop, lease.generation = desktop, 1 + lease.processes = [SimpleNamespace(pid=123, poll=lambda: None)] + assert lease.inspect_dialogs(123) == (script_dialog(),) + lease.acknowledge_dialog(script_dialog()) + assert not lease.inspect_dialogs(999) + owner.generation = 2 + assert not lease.inspect_dialogs(123) + with pytest.raises(WorkerMonitorError, match='stale'): + lease.acknowledge_dialog(script_dialog()) + assert calls == [123, 'ack'] + + +def test_session_acknowledges_known_error_then_quits_without_claiming_success(tmp_path, monkeypatch): + from test_isolated_cad import fake_desktop + from dx_productivity.trial_task_center import isolated_cad as runtime + events, cad = fake_desktop(monkeypatch, tmp_path) + session = runtime.IsolatedCadSession(tmp_path) + session.__enter__() + rows = [script_dialog()] + session.desktop.inspect_dialogs = lambda pid: tuple(rows) + session.desktop.acknowledge_dialog = lambda row: rows.clear() + with pytest.raises(runtime.WorkerMonitorError, match='script error'): + session.__exit__(None, None, None) + assert not rows and events.count('quit') == 1 + assert cad.poll() == 0 and session.record['orderly_shutdown'] + assert session.record['clean'] is False + assert (tmp_path / 'uncertain.flag').exists() + + +def test_startup_script_error_is_acknowledged_and_cannot_enter_project_work(tmp_path, monkeypatch): + from test_isolated_cad import fake_desktop + from dx_productivity.trial_task_center import isolated_cad as runtime + events, cad = fake_desktop(monkeypatch, tmp_path) + rows = [script_dialog()] + monkeypatch.setattr(runtime.PrivateDesktop, 'inspect_dialogs', lambda self, pid: tuple(rows), raising=False) + monkeypatch.setattr(runtime.PrivateDesktop, 'acknowledge_dialog', lambda self, row: rows.clear(), raising=False) + with pytest.raises(runtime.PrivateCadStartupError, match='compilation error'): + with runtime.IsolatedCadSession(tmp_path): + pytest.fail('acknowledging a fatal popup must not authorize project work') + assert not rows and cad.poll() is not None + assert ('release', False) in events + + +@pytest.mark.skipif(os.name != 'nt', reason='Win32 action boundary') +def test_changed_prompt_or_recycled_window_handle_is_not_acknowledged(tmp_path, monkeypatch): + import win32gui + from dx_productivity.trial_task_center import cad_dialogs + expected = script_dialog() + monkeypatch.setattr(cad_dialogs, 'inspect_owned_dialogs', + lambda *_: (script_dialog(title='Save Changes', text='Save changes?'),)) + monkeypatch.setattr(win32gui, 'PostMessage', lambda *_: pytest.fail('changed HWND clicked')) + with pytest.raises(OSError, match='changed'): + cad_dialogs.acknowledge_owned_dialog(None, 'dx-owned', 123, expected) + + +def test_protected_wait_finishes_when_user_dismisses_dialog_and_owned_processes_exit(tmp_path, monkeypatch): + from threading import Event, Thread + from test_isolated_cad import fake_desktop + from dx_productivity.trial_task_center import isolated_cad as runtime + from dx_productivity.trial_task_center.stop_control import StopControl + from dx_productivity.trial_task_center import worker_monitor + events, cad = fake_desktop(monkeypatch, tmp_path, cad_exit_code=None) + control = StopControl() + session = runtime.IsolatedCadSession(tmp_path, stop_control=control) + session.__enter__() + rows = [script_dialog(title='Save Changes', text='Save changes to Board.prj?')] + session.desktop.inspect_dialogs = lambda pid: tuple(rows) + session.desktop.acknowledge_dialog = lambda row: pytest.fail('save prompt clicked') + start = session.desktop.start_process + def start_quit(command, **kwargs): + process = start(command, **kwargs) + if command[0] == 'quit': + process.wait = lambda timeout: (_ for _ in ()).throw(subprocess.TimeoutExpired('quit', timeout)) + process.poll = lambda: None if rows else 0 + return process + session.desktop.start_process = start_quit + # Exercise timeout recovery without waiting for the normal 20 second budget. + clock = [0.0] + monkeypatch.setattr(runtime.time, 'monotonic', lambda: clock[0]) + session.desktop.inspect_dialogs = lambda pid: (clock.__setitem__(0, clock[0] + 21) or tuple(rows)) + waiting, finished = Event(), Event() + publish = worker_monitor._publish_progress + def observe(path, snapshot): + publish(path, snapshot) + if snapshot.get('stage') == 'awaiting_reconciliation': + waiting.set() + monkeypatch.setattr(worker_monitor, '_publish_progress', observe) + errors = [] + def close(): + try: + session.__exit__(None, None, None) + except Exception as error: + errors.append(error) + finally: + finished.set() + thread = Thread(target=close) + thread.start() + try: + assert waiting.wait(2) + assert not finished.is_set() and cad.poll() is None + rows.clear() # The operator handled the unknown prompt. + cad.returncode = 0 + assert finished.wait(2), 'completed owned processes must release without requiring force' + assert not control.force_event.is_set() + assert errors and session.record['clean'] is False + assert events.count('quit') == 1 and (tmp_path / 'uncertain.flag').exists() + finally: + control.request_force() + thread.join(3) + + +@pytest.mark.skipif(os.name != 'nt', reason='Native owned private-desktop MessageBox samples') +@pytest.mark.parametrize('known', [True, False]) +def test_real_private_desktop_messagebox_is_handled_without_touching_input_desktop(tmp_path, known): + import sys + import time + from uuid import uuid4 + from dx_productivity.trial_task_center.cad_dialogs import CadDialogGuard + from dx_productivity.trial_task_center.isolated_desktop import PrivateDesktop + text = 'Microsoft VBScript compilation error\nName redefined: VdFoo' if known else 'Save changes to Board.prj?' + title = 'Script Error' if known else 'Save Changes' + code = 'import ctypes; ctypes.windll.user32.MessageBoxW(None, ' + repr(text) + ', ' + repr(title) + ', 0)' + with PrivateDesktop('dx-' + uuid4().hex, enabled=True) as desktop: + process = desktop.start_process((sys.executable, '-c', code)) + guard = CadDialogGuard(desktop, process, tmp_path / 'cad-dialogs.json', 'sample') + deadline = time.monotonic() + 10 + while not (guard.failure if known else guard.summary()['dialogs_seen']) and time.monotonic() < deadline: + guard.poll('closing') + time.sleep(.05) + assert guard.summary()['dialogs_seen'] >= 1 + if known: + assert guard.records[-1]['action'] == 'acknowledge_script_error', guard.records + assert process.wait(timeout=3) == 0 + assert guard.failure + else: + assert process.poll() is None + assert guard.summary()['blocked'] + assert desktop.cleanup_record['desktop_confirmation']['released'] + + +@pytest.mark.parametrize('directory', ['tasks/task/quick-run', 'batch-resources/batch/generation-1']) +def test_dialog_evidence_is_in_diagnostic_bundle_and_scrubbed(tmp_path, directory): + import zipfile + from dx_productivity.trial_task_center.diagnostics_bundle import export_diagnostic_bundle + path = tmp_path / 'data' / directory / ('cad-dialogs-' + 'a' * 32 + '.json') + path.parent.mkdir(parents=True) + path.write_text(json.dumps({'text': 'C:/Users/Alice/Board/script.vbs'}), encoding='utf-8') + bundle = export_diagnostic_bundle(tmp_path / 'data', tmp_path / 'diagnostics.zip') + with zipfile.ZipFile(bundle) as archive: + content = archive.read(path.relative_to(tmp_path / 'data').as_posix()).decode() + assert 'Alice' not in content and '' in content + + +@pytest.mark.skipif(os.name != 'nt', reason='Native modal dialog while the business thread waits') +def test_dialog_is_serviced_while_business_thread_is_blocked(tmp_path): + import sys + from dx_productivity.trial_task_center import isolated_cad as runtime + from dx_productivity.trial_task_center.cad_dialogs import CadDialogGuard + from dx_productivity.trial_task_center.batch_runtime import BatchCadRuntime, _DesktopLease + code = "import ctypes; ctypes.windll.user32.MessageBoxW(None, 'Microsoft VBScript compilation error', 'Script Error', 0)" + with BatchCadRuntime(tmp_path / 'runtime', 'dialog-sample') as batch: + lease = _DesktopLease(batch, tmp_path) + lease.__enter__() + process = lease.start_process((sys.executable, '-c', code)) + session = runtime.IsolatedCadSession(tmp_path, desktop=lease) + session.cad = process + session._dialogs = CadDialogGuard(lease, process, tmp_path / 'cad-dialogs.json', session.token) + session._start_dialog_monitor() + try: + assert process.wait(timeout=5) == 0 # No polling from this blocked thread. + assert session._dialogs.failure + finally: + session._stop_dialog_monitor() + lease.close() + assert not session._dialog_thread.is_alive() + assert batch.desktop.cleanup_record['desktop_confirmation']['released']