answer42 0.5.2__tar.gz → 0.5.4__tar.gz

{answer42-0.5.2 → answer42-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: answer42
-Version: 0.5.2
+Version: 0.5.4
 Summary: Answer42 — The Answer to Life, Universe, and 1C — UI Driver. MCP-powered 1C:Enterprise UI automation: click, fill, navigate, test, and introspect managed forms through the test-client API
 Author: Marvin (AI Assistant), 42Clouds, and contributors
 Author-email: "Kosolapov Stanislav (proDOOMman)" <prodoomman@gmail.com>

{answer42-0.5.2 → answer42-0.5.4}/docs/architecture.md

@@ -109,7 +109,11 @@ class SessionState:
 
 ### `mcp_1c.window_control`
 
-OS-specific слой окна тест-клиента: Linux (`wmctrl`/`xdotool`/`python-xlib`, `xwininfo`), Windows (WinAPI). Допускается для подготовки геометрии окна и скриншотов (resize/maximize/geometry capture). Ввод, клики и результат действий 1С не определяются через X11/WinAPI; автоматизация 1С идёт через API клиента тестирования.
+OS-specific слой окна тест-клиента: Linux (`wmctrl`/`xdotool`/`python-xlib`, `xwininfo`), Windows (WinAPI; для скрытых рабочих столов — через `mcp_1c.win_desktop`). Допускается для подготовки геометрии окна и скриншотов (resize/maximize/geometry capture). Ввод, клики и результат действий 1С не определяются через X11/WinAPI; автоматизация 1С идёт через API клиента тестирования.
+
+### `mcp_1c.win_desktop`
+
+Windows-аналог Xvfb: скрытые рабочие столы (`CreateDesktopW` в `WinSta0`), `DesktopPopen` — `subprocess.Popen` с `STARTUPINFO.lpDesktop` (CPython его не поддерживает), перечисление окон рабочего стола, `PrintWindow`-скриншоты и maximize из вспомогательного потока, привязанного к рабочему столу через `SetThreadDesktop`. Включается `ONEC_MCP_WINDOWS_DESKTOP=hidden`; тогда `session.display`/`client_display` содержат имена рабочих столов.
 
 ### `mcp_1c.runtime`
 
@@ -233,6 +237,7 @@ large remote infobases.
 | `ONEC_MCP_WS_HOST` | WebSocket host | `127.0.0.1` |
 | `ONEC_MCP_WS_PORT` | WebSocket port | `8765` |
 | `ONEC_MCP_REQUEST_TIMEOUT` | Таймаут запроса, сек | `60` |
+| `ONEC_MCP_WINDOWS_DESKTOP` | Windows: `hidden` — запускать менеджер и клиент 1С на скрытых рабочих столах сессии; `current` — на текущем рабочем столе | `current` |
 | `ONEC_MCP_DATA_DIR` | Рабочая директория | OS tempdir + `answer42` (`/tmp/answer42` on Linux, `%TEMP%\answer42` on Windows) |
 | `MCP_1C_RAG_DB` | Путь к RAG SQLite | `build/rag/onec-rag.sqlite` |
 | `ONEC_MCP_DISABLE_RAG` | Отключить встроенный RAG (`1/true/yes/on`) | пусто |

{answer42-0.5.2 → answer42-0.5.4}/docs/installation.md

@@ -52,6 +52,18 @@ python scripts/build_cf.py src/client_cf build/MCPTestClient.cf
 
 На Linux без серверных компонентов Answer42 может запускать менеджер и клиент напрямую через файловую базу (`/F`). На Windows это также поддерживается; запускайте MCP из интерактивной пользовательской сессии, потому что UI automation и screenshots требуют desktop session.
 
+### Фоновый режим на Windows (скрытый рабочий стол)
+
+По умолчанию на Windows менеджер и клиент тестирования открываются на текущем рабочем столе пользователя. Чтобы они работали в фоне и не мешали работе (аналог Xvfb на Linux), задайте:
+
+```powershell
+$env:ONEC_MCP_WINDOWS_DESKTOP = "hidden"
+```
+
+или в MCP-конфиге `"env": {"ONEC_MCP_WINDOWS_DESKTOP": "hidden"}`. Для каждой сессии Answer42 создаёт в `WinSta0` два скрытых рабочих стола (`Answer42-<scope>-<session>-manager` и `...-client`) и запускает `1cv8c` на них через `STARTUPINFO.lpDesktop`. Окна 1С не появляются на экране, не забирают фокус и не видны в панели задач. Screenshots снимаются через `PrintWindow`, auto-maximize работает на скрытом рабочем столе.
+
+Ограничения: процесс MCP по-прежнему должен работать в интерактивной сессии пользователя (скрытый рабочий стол принадлежит его window station); Windows service в session 0 не подходит. Посмотреть окна на скрытом рабочем столе можно только через `screenshot`.
+
 ## Рекомендации для агентов
 
 Answer42 больше не поставляет bundled skills. Рабочие рекомендации находятся в

{answer42-0.5.2 → answer42-0.5.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "answer42"
-version = "0.5.2"
+version = "0.5.4"
 description = "Answer42 — The Answer to Life, Universe, and 1C — UI Driver. MCP-powered 1C:Enterprise UI automation: click, fill, navigate, test, and introspect managed forms through the test-client API"
 readme = "README.md"
 requires-python = ">=3.11"

{answer42-0.5.2 → answer42-0.5.4}/src/mcp_1c/runtime.py

@@ -22,7 +22,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
-from . import os_support
+from . import os_support, win_desktop
 
 LOGGER = logging.getLogger(__name__)
 
@@ -143,19 +143,30 @@ def require_xvfb() -> str:
     return xvfb_bin
 
 
-def session_displays(display_offset: int) -> tuple[str, str, bool]:
+def session_displays(display_offset: int, session_key: str = "") -> tuple[str, str, bool]:
     """Choose inherited desktop display or two Answer42-owned Xvfb displays.
 
     Returns ``(manager_display, client_display, starts_xvfb)``. A live X11
     display is deliberately shared by manager and client: it is the caller's
     explicit request to run visibly on that desktop. Otherwise the historical
     isolated two-Xvfb setup is retained for headless operation.
+
+    On Windows the "display" is either empty (the user's current desktop) or,
+    with ``ONEC_MCP_WINDOWS_DESKTOP=hidden``, the names of two hidden desktops
+    for manager and client; they are created lazily when 1C is launched.
     """
     desktop_display = inherited_x11_display()
     if desktop_display:
         return desktop_display, desktop_display, False
     if os_support.IS_WINDOWS:
-        return "", "", False
+        if not win_desktop.hidden_desktop_enabled():
+            return "", "", False
+        key = session_key or str(display_offset)
+        return (
+            win_desktop.session_desktop_name(key, "manager"),
+            win_desktop.session_desktop_name(key, "client"),
+            False,
+        )
     require_xvfb()
     manager_display = find_free_display(DEFAULT_DISPLAY_START + display_offset)
     # The first X socket does not exist until start_xvfb() is called, so derive
@@ -186,6 +197,23 @@ def stop_xvfb(proc: subprocess.Popen | None) -> None:
     kill_process(proc, "Xvfb")
 
 
+def release_display(display: str) -> None:
+    """Release an Answer42-owned hidden Windows desktop; no-op for X11 displays."""
+    if win_desktop.is_hidden_desktop_name(display):
+        win_desktop.release_desktop(display)
+
+
+def _popen_on_display(argv: list[str], display: str, **kwargs: Any) -> subprocess.Popen:
+    """Start a 1C process on the given X11 display or hidden Windows desktop."""
+    env = kwargs.pop("env", None) or os.environ.copy()
+    if win_desktop.is_hidden_desktop_name(display):
+        win_desktop.ensure_desktop(display)
+        return win_desktop.DesktopPopen(argv, desktop=display, env=env, **kwargs)
+    if display:
+        env["DISPLAY"] = display
+    return subprocess.Popen(argv, env=env, **kwargs)
+
+
 def is_port_listening(host: str, port: int, timeout: float = 1.0) -> bool:
     """Return True if something accepts TCP connections on host:port."""
     try:
@@ -534,16 +562,13 @@ def _start_thin_test_manager_argv(
     argv = add_1c_out_args_before_testmanager(argv, onec_out_path)
     with log_path.open("ab", buffering=0) as log_handle:
         LOGGER.info("Starting thin test manager: %s", " ".join(argv))
-        env = os.environ.copy()
-        if display:
-            env["DISPLAY"] = display
-        proc = subprocess.Popen(
+        proc = _popen_on_display(
             argv,
+            display,
             stdout=log_handle,
             stderr=log_handle,
             stdin=subprocess.DEVNULL,
             **os_support.subprocess_creation_kwargs(),
-            env=env,
         )
         proc.answer42_stdout_log_path = str(log_path)  # type: ignore[attr-defined]
         proc.answer42_out_log_path = str(onec_out_path)  # type: ignore[attr-defined]
@@ -662,16 +687,13 @@ def start_test_client(
     stdout_log_path = log_dir / log_name
     with stdout_log_path.open("ab", buffering=0) as log_handle:
         LOGGER.info("Starting test client: %s", " ".join(argv))
-        env = os.environ.copy()
-        if display:
-            env["DISPLAY"] = display
-        proc = subprocess.Popen(
+        proc = _popen_on_display(
             argv,
+            display,
             stdout=log_handle,
             stderr=log_handle,
             stdin=subprocess.DEVNULL,
             **os_support.subprocess_creation_kwargs(),
-            env=env,
         )
         proc.answer42_stdout_log_path = str(stdout_log_path)  # type: ignore[attr-defined]
         proc.answer42_argv = argv  # type: ignore[attr-defined]

{answer42-0.5.2 → answer42-0.5.4}/src/mcp_1c/server.py

@@ -31,7 +31,7 @@ from mcp.server.mcpserver.resources import FileResource
 from mcp.server.subscriptions import ToolsListChanged
 from starlette.responses import FileResponse, PlainTextResponse
 
-from . import __version__, os_support, release_helper, runtime, skill_installer
+from . import __version__, os_support, release_helper, runtime, skill_installer, win_desktop
 from . import platform as _platform
 from .auth import build_auth_settings, build_token_verifier, load_static_token_config
 from .auth import current_account_id as _current_account_id
@@ -1614,6 +1614,8 @@ async def _cleanup_failed_start_session(sess: SessionState, reason: str) -> None
         pass
     runtime.stop_xvfb(sess.client_xvfb_process)
     runtime.stop_xvfb(sess.xvfb_process)
+    runtime.release_display(sess.client_display)
+    runtime.release_display(sess.display)
     _cleanup_stale_session_processes(sess, reason)
     if sess.data_dir.exists():
         shutil.rmtree(sess.data_dir, ignore_errors=True)
@@ -4688,7 +4690,9 @@ async def start_session(
     with _port_allocation_lock():
         port_offset = _stable_session_port_offset(sid)
         display_offset = port_offset // _PORT_BAND_SIZE
-        display, client_display, starts_xvfb = runtime.session_displays(display_offset)
+        display, client_display, starts_xvfb = runtime.session_displays(
+            display_offset, session_key=f"{SESSION_SCOPE_ID or 'local'}-{sid}"
+        )
         ws_port = _find_session_port(runtime.DEFAULT_WS_PORT, port_offset, sub_offset=0)
         ibsrv_port = _find_session_port(runtime.DEFAULT_IBSRV_HTTP_PORT, port_offset, sub_offset=0)
         ibsrv_direct_regport = _find_session_port(runtime.DEFAULT_IBSRV_DIRECT_PORT, port_offset, sub_offset=0)
@@ -5053,6 +5057,8 @@ async def _stop_session_impl(session_id: str = DEFAULT_SESSION, clean_data: bool
     stopped.append("client-xvfb")
     runtime.stop_xvfb(sess.xvfb_process)
     stopped.append("xvfb")
+    runtime.release_display(sess.client_display)
+    runtime.release_display(sess.display)
     _cleanup_stale_session_processes(sess, "stop_session")
     stopped.append("stale-processes")
     if clean_data and sess.data_dir.exists():
@@ -7027,6 +7033,95 @@ def universal_report_workflow() -> str:
 """
 
 
+@mcp.prompt(
+    name="event_log_workflow",
+    title="Журнал регистрации 1С",
+    description="Встроенный workflow просмотра, фильтрации, проверки и безопасной выгрузки Журнала регистрации 1С.",
+)
+def event_log_workflow() -> str:
+    """Return reusable instructions for the standard 1C Event Log form."""
+    return """# Журнал регистрации 1С через Answer42
+
+Используй этот workflow для расследования событий в стандартной обработке
+«Журнал регистрации». Журнал может быть недоступен без роли просмотра или в
+конкретной конфигурации: сначала найди объект через `rag_lookup_object`/
+`rag_query`, затем открой найденную app-навигацию. В УНФ 3.0 проверена ссылка
+`e1cib/app/Обработка.ЖурналРегистрации`.
+
+## Безопасность и доказательства
+
+- Журнал содержит персональные данные, имена пользователей, IP/порты, данные
+  событий и комментарии. Не выгружай широкий журнал и не пересылай сырые записи,
+  пока пользователь не подтвердил временной интервал и получателя.
+- Сначала сузь период, затем добавляй только необходимые отборы. Не меняй
+  параметры регистрации событий и не удаляй журнал: workflow предназначен для
+  чтения и контролируемого экспорта.
+- Не угадывай имена или состав полей: после открытия вызови
+  `ui_tree(profile="navigation")`; перед сложным отбором используй
+  `ui_tree(profile="full", include_hidden=true)` и RAG для формы отбора.
+
+## Основной экран
+
+В проверенной УНФ-форме есть:
+
+- `КоличествоПоказываемыхСобытий` («Показывать») — ограничение числа строк;
+- `Критичность` («Важность») — быстрый уровень важности;
+- `ПредставлениеОтбора` — текст действующего отбора;
+- таблица `Журнал`, команды `Интервал`, `Установить отбор`, `Отключить отбор`,
+  `Вывести список...`, `Выгрузить в файл...`, а также поиск.
+
+Сначала зафиксируй текущие значения этих полей и количество/видимые колонки
+таблицы. Команды просмотра события и отбора по текущей колонке требуют выбранной
+строки/колонки; не вызывай их, пока не проверишь доступность через `ui_tree`.
+
+## Интервал и отбор
+
+1. Нажми `Интервал` для малого, явно согласованного периода и подтверди его.
+   Повторно прочитай `ПредставлениеОтбора` и строки `Журнал`.
+2. Для составного отбора нажми `Установить отбор`. В стандартной форме
+   `ОтборЖурналаРегистрации` сначала прочитай live UI; ожидаемые группы и поля:
+   - **даты:** `ДатаНачала`, `ДатаОкончания`, `ВыбратьПериод`;
+   - **основные:** `Важность`, `События`, `Пользователи`, `Сеансы`;
+   - **приложение/компьютер:** `Приложения`, `Компьютеры`;
+   - **разделение:** `ОбластиДанных`, `РазделениеДанныхСеанса`;
+   - **сведения:** `Метаданные`, `Комментарий`, `Данные`,
+     `ПредставлениеДанных` и при необходимости `ДанныеСписок`;
+   - **транзакция:** `СтатусТранзакции`, `Транзакция`;
+   - **сервер:** `РабочиеСерверы`, `ОсновныеIPПорты`, `ВспомогательныеIPПорты`.
+3. Списочные поля и флажки нельзя надежно заполнять строкой наугад. Открой
+   dropdown/стандартный выбор, прочитай доступные значения, выбери только явно
+   заданные пользователем и затем снова проверь форму. Для «Важность» и
+   «Статус транзакции» форма использует отдельные check/value-поля — проверь
+   реальные доступные элементы перед изменением.
+4. Нажми `Применить`, дождись обновления и проверь итоговую строку отбора,
+   число строк и несколько строк результата через `table_rows(name="Журнал")`.
+5. `Отключить отбор` снимает текущий отбор целиком. Используй его только по
+   явной просьбе; для нового расследования лучше открывай форму отбора и меняй
+   только нужные критерии.
+
+## Анализ строк
+
+- Для текстового поиска по уже загруженным строкам используй `dynamic_list_find`
+  или кнопку «Расширенный поиск», но не подменяй им серверный отбор: поиск
+  работает по представленным данным и не заменяет интервал/критерии журнала.
+- Перед «Открыть» или «Открыть данные для просмотра» выбери конкретную строку,
+  затем прочитай открывшуюся форму через `ui_tree`. Данные события могут быть
+  объёмными и чувствительными; извлекай только минимально нужный фрагмент.
+- Для воспроизводимого результата укажи: период, все критерии, лимит
+  «Показывать», количество строк и идентификаторы/даты проверенных событий.
+
+## Выгрузка
+
+- `Вывести список...` применяй для табличного представления текущей выборки;
+  проверяй результат структурными средствами `tabular_documents` и
+  `tabular_document_text`, а большую выборку сохраняй через `tabular_document_save`.
+- `Выгрузить в файл...` предназначена для передачи в техподдержку. Это может
+  включать чувствительные данные: сначала потребуй явное подтверждение объёма и
+  получателя, затем подготовь узкий отбор. Проверь путь, формат и `saved=true`;
+  при блокировке клиента используй `client_busy_status`/`wait_client_idle`.
+"""
+
+
 def _query_from_navigation_link(value: str) -> str:
     text = str(value or "").strip()
     if text.startswith("e1cib/"):
@@ -10371,6 +10466,31 @@ def _register_screenshot_url(path: Path) -> dict[str, Any] | None:
     }
 
 
+def _capture_hidden_desktop_screenshot(
+    desktop: str, output_path: Path, *, window: bool
+) -> tuple[dict[str, Any] | None, str, str]:
+    """Capture a 1C window from an Answer42 hidden Windows desktop.
+
+    A hidden desktop is never composed on screen, so there is no "whole
+    display" bitmap: the fallback is the largest visible window there.
+    """
+    geometry = _active_external_1c_window_geometry(display=desktop) if window else None
+    fallback = ""
+    fallback_reason = ""
+    if geometry is None:
+        windows = [w for w in win_desktop.list_windows(desktop) if w["width"] >= 100 and w["height"] >= 100]
+        if not windows:
+            raise RuntimeError(f"Cannot capture screenshot: no visible windows on hidden desktop {desktop!r}")
+        largest = max(windows, key=lambda w: w["width"] * w["height"])
+        geometry = {key: largest[key] for key in ("left", "top", "width", "height", "title", "hwnd")}
+        geometry["desktop"] = desktop
+        if window:
+            fallback = "largest_window"
+            fallback_reason = "1C window was not detected on the hidden desktop; captured the largest window instead"
+    win_desktop.capture_window_png(desktop, int(geometry["hwnd"]), int(geometry["width"]), int(geometry["height"]), output_path)
+    return (geometry if window else None), fallback, fallback_reason
+
+
 @mcp.tool()
 def screenshot(
     path: Annotated[str, "Output image path"] = "build/screenshots/screenshot.png",
@@ -10402,7 +10522,11 @@ def screenshot(
         geometry: dict[str, Any] | None = None
         fallback = ""
         fallback_reason = ""
-        if os_support.IS_WINDOWS:
+        if win_desktop.is_hidden_desktop_name(resolved_display):
+            geometry, fallback, fallback_reason = _capture_hidden_desktop_screenshot(
+                resolved_display, output_path, window=window
+            )
+        elif os_support.IS_WINDOWS:
             geometry = _active_external_1c_window_geometry() if window else None
             if window and geometry is None:
                 fallback = "full_display"
@@ -10588,6 +10712,8 @@ async def _cleanup_sessions() -> None:
             pass
         runtime.stop_xvfb(sess.client_xvfb_process)
         runtime.stop_xvfb(sess.xvfb_process)
+        runtime.release_display(sess.client_display)
+        runtime.release_display(sess.display)
     if SESSION_SCOPE_ID:
         _persist_sessions()
         _mark_global_sessions_orphaned_for_owner()

answer42-0.5.4/src/mcp_1c/win_desktop.py

@@ -0,0 +1,399 @@
+"""Hidden Windows desktops for background 1C test-manager/test-client runs.
+
+This is the Windows counterpart of the Linux Xvfb displays.  A separate
+desktop object (``CreateDesktopW``) is created inside the interactive window
+station ``WinSta0``; 1C processes started with ``STARTUPINFO.lpDesktop``
+pointing at it render their windows there, so nothing appears on the user's
+current desktop and focus is never stolen.
+
+The desktop is still part of the user's logon session, so the MCP server must
+run in an interactive session (not a service in session 0).  Screenshots use
+``PrintWindow(PW_RENDERFULLCONTENT)`` from a helper thread attached to the
+desktop, because ``BitBlt`` of a desktop that is not the input desktop yields
+black frames.
+
+The module imports ctypes WinAPI bindings lazily so that importing Answer42 on
+POSIX does not fail.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import struct
+import subprocess
+import threading
+import zlib
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, TypeVar
+
+LOGGER = logging.getLogger(__name__)
+
+IS_WINDOWS = os.name == "nt"
+
+DESKTOP_MODE_ENV = "ONEC_MCP_WINDOWS_DESKTOP"
+DESKTOP_MODE_CURRENT = "current"
+DESKTOP_MODE_HIDDEN = "hidden"
+DESKTOP_PREFIX = "Answer42-"
+WINDOW_STATION = "WinSta0"
+
+_GENERIC_ALL = 0x10000000
+_STARTF_USESTDHANDLES = 0x00000100
+_CREATE_UNICODE_ENVIRONMENT = 0x00000400
+_PW_RENDERFULLCONTENT = 0x00000002
+_SW_RESTORE = 9
+_SW_MAXIMIZE = 3
+
+_T = TypeVar("_T")
+
+_DESKTOPS: dict[str, int] = {}
+_DESKTOPS_LOCK = threading.Lock()
+_api: Any = None
+
+
+def desktop_mode() -> str:
+    """Return the configured Windows desktop mode: ``current`` or ``hidden``."""
+    value = (os.getenv(DESKTOP_MODE_ENV) or "").strip().lower()
+    if value in {"hidden", "background", "1", "true", "yes", "on"}:
+        return DESKTOP_MODE_HIDDEN
+    return DESKTOP_MODE_CURRENT
+
+
+def hidden_desktop_enabled() -> bool:
+    return IS_WINDOWS and desktop_mode() == DESKTOP_MODE_HIDDEN
+
+
+def session_desktop_name(session_key: str, role: str) -> str:
+    """Build a stable desktop name; desktop names must not contain backslashes."""
+    safe = re.sub(r"[^A-Za-z0-9_.-]+", "_", f"{session_key}-{role}").strip("_") or role
+    return f"{DESKTOP_PREFIX}{safe}"[:200]
+
+
+def is_hidden_desktop_name(value: str) -> bool:
+    return bool(IS_WINDOWS and value and value.startswith(DESKTOP_PREFIX))
+
+
+def lpdesktop(name: str) -> str:
+    return f"{WINDOW_STATION}\\{name}"
+
+
+def _winapi() -> Any:
+    """Lazily bind the WinAPI functions used here."""
+    global _api
+    if _api is not None:
+        return _api
+    import ctypes
+    import ctypes.wintypes as wt
+
+    user32 = ctypes.WinDLL("user32", use_last_error=True)
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    gdi32 = ctypes.WinDLL("gdi32", use_last_error=True)
+
+    class STARTUPINFOW(ctypes.Structure):
+        _fields_ = [
+            ("cb", wt.DWORD), ("lpReserved", wt.LPWSTR), ("lpDesktop", wt.LPWSTR), ("lpTitle", wt.LPWSTR),
+            ("dwX", wt.DWORD), ("dwY", wt.DWORD), ("dwXSize", wt.DWORD), ("dwYSize", wt.DWORD),
+            ("dwXCountChars", wt.DWORD), ("dwYCountChars", wt.DWORD), ("dwFillAttribute", wt.DWORD),
+            ("dwFlags", wt.DWORD), ("wShowWindow", wt.WORD), ("cbReserved2", wt.WORD),
+            ("lpReserved2", ctypes.c_void_p), ("hStdInput", wt.HANDLE), ("hStdOutput", wt.HANDLE),
+            ("hStdError", wt.HANDLE),
+        ]
+
+    class PROCESS_INFORMATION(ctypes.Structure):
+        _fields_ = [("hProcess", wt.HANDLE), ("hThread", wt.HANDLE), ("dwProcessId", wt.DWORD), ("dwThreadId", wt.DWORD)]
+
+    class BITMAPINFOHEADER(ctypes.Structure):
+        _fields_ = [
+            ("biSize", wt.DWORD), ("biWidth", wt.LONG), ("biHeight", wt.LONG), ("biPlanes", wt.WORD),
+            ("biBitCount", wt.WORD), ("biCompression", wt.DWORD), ("biSizeImage", wt.DWORD),
+            ("biXPelsPerMeter", wt.LONG), ("biYPelsPerMeter", wt.LONG), ("biClrUsed", wt.DWORD),
+            ("biClrImportant", wt.DWORD),
+        ]
+
+    user32.CreateDesktopW.restype = wt.HANDLE
+    user32.CreateDesktopW.argtypes = [wt.LPCWSTR, wt.LPCWSTR, ctypes.c_void_p, wt.DWORD, wt.DWORD, ctypes.c_void_p]
+    user32.OpenDesktopW.restype = wt.HANDLE
+    user32.OpenDesktopW.argtypes = [wt.LPCWSTR, wt.DWORD, wt.BOOL, wt.DWORD]
+    user32.CloseDesktop.argtypes = [wt.HANDLE]
+    user32.SetThreadDesktop.argtypes = [wt.HANDLE]
+    user32.EnumDesktopWindows.argtypes = [wt.HANDLE, ctypes.c_void_p, wt.LPARAM]
+    user32.PrintWindow.argtypes = [wt.HWND, wt.HDC, wt.UINT]
+    user32.GetDC.restype = wt.HDC
+    user32.GetDC.argtypes = [wt.HWND]
+    user32.ReleaseDC.argtypes = [wt.HWND, wt.HDC]
+    user32.GetWindowTextLengthW.argtypes = [wt.HWND]
+    user32.GetWindowTextW.argtypes = [wt.HWND, wt.LPWSTR, ctypes.c_int]
+    user32.GetWindowRect.argtypes = [wt.HWND, ctypes.POINTER(wt.RECT)]
+    user32.IsWindowVisible.argtypes = [wt.HWND]
+    user32.GetWindowThreadProcessId.argtypes = [wt.HWND, ctypes.POINTER(wt.DWORD)]
+    user32.ShowWindow.argtypes = [wt.HWND, ctypes.c_int]
+    user32.MoveWindow.argtypes = [wt.HWND, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, wt.BOOL]
+    kernel32.CreateProcessW.argtypes = [
+        wt.LPCWSTR, wt.LPWSTR, ctypes.c_void_p, ctypes.c_void_p, wt.BOOL, wt.DWORD,
+        ctypes.c_void_p, wt.LPCWSTR, ctypes.c_void_p, ctypes.c_void_p,
+    ]
+    kernel32.CloseHandle.argtypes = [wt.HANDLE]
+    gdi32.CreateCompatibleDC.restype = wt.HDC
+    gdi32.CreateCompatibleDC.argtypes = [wt.HDC]
+    gdi32.CreateCompatibleBitmap.restype = wt.HBITMAP
+    gdi32.CreateCompatibleBitmap.argtypes = [wt.HDC, ctypes.c_int, ctypes.c_int]
+    gdi32.SelectObject.restype = wt.HGDIOBJ
+    gdi32.SelectObject.argtypes = [wt.HDC, wt.HGDIOBJ]
+    gdi32.GetDIBits.argtypes = [wt.HDC, wt.HBITMAP, wt.UINT, wt.UINT, ctypes.c_void_p, ctypes.c_void_p, wt.UINT]
+    gdi32.DeleteObject.argtypes = [wt.HGDIOBJ]
+    gdi32.DeleteDC.argtypes = [wt.HDC]
+
+    class _Api:
+        pass
+
+    api = _Api()
+    api.ctypes = ctypes
+    api.wt = wt
+    api.user32 = user32
+    api.kernel32 = kernel32
+    api.gdi32 = gdi32
+    api.STARTUPINFOW = STARTUPINFOW
+    api.PROCESS_INFORMATION = PROCESS_INFORMATION
+    api.BITMAPINFOHEADER = BITMAPINFOHEADER
+    api.EnumWindowsProc = ctypes.WINFUNCTYPE(wt.BOOL, wt.HWND, wt.LPARAM)
+    _api = api
+    return api
+
+
+def _last_error(api: Any, what: str) -> OSError:
+    err = api.ctypes.get_last_error()
+    return OSError(err, f"{what} failed: {api.ctypes.FormatError(err).strip()}")
+
+
+def ensure_desktop(name: str) -> None:
+    """Create (or open) the named desktop and keep a handle until release_desktop()."""
+    if not IS_WINDOWS:
+        raise RuntimeError("Hidden desktops are only available on Windows")
+    api = _winapi()
+    with _DESKTOPS_LOCK:
+        if name in _DESKTOPS:
+            return
+        handle = api.user32.CreateDesktopW(name, None, None, 0, _GENERIC_ALL, None)
+        if not handle:
+            raise _last_error(api, f"CreateDesktopW({name!r})")
+        _DESKTOPS[name] = int(handle)
+    LOGGER.info("Hidden desktop ready: %s", lpdesktop(name))
+
+
+def release_desktop(name: str) -> None:
+    """Close our handle; Windows destroys the desktop after its last process exits."""
+    if not name or not IS_WINDOWS:
+        return
+    with _DESKTOPS_LOCK:
+        handle = _DESKTOPS.pop(name, None)
+    if handle:
+        _winapi().user32.CloseDesktop(handle)
+        LOGGER.info("Released hidden desktop %s", name)
+
+
+def _open_desktop(name: str) -> int:
+    api = _winapi()
+    handle = api.user32.OpenDesktopW(name, 0, False, _GENERIC_ALL)
+    if not handle:
+        raise _last_error(api, f"OpenDesktopW({name!r})")
+    return int(handle)
+
+
+def run_on_desktop(name: str, fn: Callable[[], _T], timeout: float = 30.0) -> _T:
+    """Run ``fn`` in a helper thread attached to the named desktop.
+
+    SetThreadDesktop only succeeds for a thread without windows or hooks, so
+    a fresh short-lived thread is used for each call.
+    """
+    api = _winapi()
+    box: dict[str, Any] = {}
+
+    def worker() -> None:
+        handle = 0
+        try:
+            handle = _open_desktop(name)
+            if not api.user32.SetThreadDesktop(handle):
+                raise _last_error(api, f"SetThreadDesktop({name!r})")
+            box["value"] = fn()
+        except BaseException as exc:
+            box["error"] = exc
+        finally:
+            if handle:
+                api.user32.CloseDesktop(handle)
+
+    thread = threading.Thread(target=worker, name=f"answer42-desktop-{name}", daemon=True)
+    thread.start()
+    thread.join(timeout)
+    if thread.is_alive():
+        raise TimeoutError(f"Operation on desktop {name!r} did not finish within {timeout}s")
+    if "error" in box:
+        raise box["error"]
+    return box["value"]
+
+
+def list_windows(name: str) -> list[dict[str, Any]]:
+    """Return visible top-level windows of the named desktop."""
+    api = _winapi()
+    user32 = api.user32
+    wt = api.wt
+    ctypes = api.ctypes
+    windows: list[dict[str, Any]] = []
+
+    def callback(hwnd: int, _lparam: int) -> bool:
+        try:
+            if not user32.IsWindowVisible(hwnd):
+                return True
+            length = user32.GetWindowTextLengthW(hwnd)
+            buf = ctypes.create_unicode_buffer(length + 1)
+            user32.GetWindowTextW(hwnd, buf, length + 1)
+            rect = wt.RECT()
+            if not user32.GetWindowRect(hwnd, ctypes.byref(rect)):
+                return True
+            pid = wt.DWORD()
+            user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
+            windows.append({
+                "hwnd": int(hwnd),
+                "title": buf.value,
+                "pid": int(pid.value),
+                "left": int(rect.left),
+                "top": int(rect.top),
+                "width": int(rect.right - rect.left),
+                "height": int(rect.bottom - rect.top),
+            })
+        except Exception:
+            pass
+        return True
+
+    handle = _open_desktop(name)
+    try:
+        user32.EnumDesktopWindows(handle, api.EnumWindowsProc(callback), 0)
+    finally:
+        user32.CloseDesktop(handle)
+    return windows
+
+
+def _png_bytes(width: int, height: int, bgra: bytes) -> bytes:
+    rows = bytearray()
+    stride = width * 4
+    for y in range(height):
+        row = bgra[y * stride:(y + 1) * stride]
+        rgb = bytearray(width * 3)
+        rgb[0::3] = row[2::4]
+        rgb[1::3] = row[1::4]
+        rgb[2::3] = row[0::4]
+        rows.append(0)
+        rows.extend(rgb)
+
+    def chunk(tag: bytes, data: bytes) -> bytes:
+        return struct.pack(">I", len(data)) + tag + data + struct.pack(">I", zlib.crc32(tag + data) & 0xFFFFFFFF)
+
+    header = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
+    return b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", header) + chunk(b"IDAT", zlib.compress(bytes(rows), 6)) + chunk(b"IEND", b"")
+
+
+def capture_window_png(name: str, hwnd: int, width: int, height: int, path: Path | str) -> Path:
+    """Render a window of the named desktop into a PNG via PrintWindow."""
+    if width <= 0 or height <= 0:
+        raise ValueError(f"Invalid window size {width}x{height}")
+    api = _winapi()
+    output_path = Path(path)
+
+    def capture() -> bytes:
+        user32, gdi32, ctypes = api.user32, api.gdi32, api.ctypes
+        screen_dc = user32.GetDC(None)
+        mem_dc = gdi32.CreateCompatibleDC(screen_dc)
+        bitmap = gdi32.CreateCompatibleBitmap(screen_dc, width, height)
+        previous = gdi32.SelectObject(mem_dc, bitmap)
+        try:
+            if not user32.PrintWindow(hwnd, mem_dc, _PW_RENDERFULLCONTENT):
+                raise _last_error(api, "PrintWindow")
+            header = api.BITMAPINFOHEADER(ctypes.sizeof(api.BITMAPINFOHEADER), width, -height, 1, 32, 0, 0, 0, 0, 0, 0)
+            buffer = ctypes.create_string_buffer(width * height * 4)
+            if not gdi32.GetDIBits(mem_dc, bitmap, 0, height, buffer, ctypes.byref(header), 0):
+                raise _last_error(api, "GetDIBits")
+            return buffer.raw
+        finally:
+            gdi32.SelectObject(mem_dc, previous)
+            gdi32.DeleteObject(bitmap)
+            gdi32.DeleteDC(mem_dc)
+            user32.ReleaseDC(None, screen_dc)
+
+    bgra = run_on_desktop(name, capture)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_bytes(_png_bytes(width, height, bgra))
+    return output_path
+
+
+def maximize_window(name: str, hwnd: int, width: int, height: int) -> None:
+    """Resize and maximize a window on the named desktop (no foreground change)."""
+    api = _winapi()
+
+    def apply() -> None:
+        api.user32.ShowWindow(hwnd, _SW_RESTORE)
+        api.user32.MoveWindow(hwnd, 0, 0, int(width), int(height), True)
+        api.user32.ShowWindow(hwnd, _SW_MAXIMIZE)
+
+    run_on_desktop(name, apply)
+
+
+def _environment_block(env: dict[str, str] | None) -> Any:
+    if env is None:
+        return None
+    items = sorted(((str(k), str(v)) for k, v in env.items()), key=lambda kv: kv[0].upper())
+    block = "".join(f"{k}={v}\0" for k, v in items) + "\0"
+    return _winapi().ctypes.create_unicode_buffer(block, len(block))
+
+
+class DesktopPopen(subprocess.Popen):
+    """``subprocess.Popen`` that starts the child on a specific Windows desktop.
+
+    CPython's ``STARTUPINFO`` does not expose ``lpDesktop``, so only process
+    creation is replaced; pipes, ``poll()``, ``wait()`` and ``kill()`` keep the
+    standard implementation.
+    """
+
+    def __init__(self, *args: Any, desktop: str, **kwargs: Any) -> None:
+        if not IS_WINDOWS:
+            raise RuntimeError("DesktopPopen is only available on Windows")
+        self._answer42_desktop = desktop
+        super().__init__(*args, **kwargs)
+
+    def _execute_child(  # type: ignore[override]
+        self, args, executable, preexec_fn, close_fds, pass_fds, cwd, env, startupinfo,
+        creationflags, shell, p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite, *unused,
+    ) -> None:
+        api = _winapi()
+        ctypes = api.ctypes
+        if shell:
+            raise ValueError("DesktopPopen does not support shell=True")
+        command_line = args if isinstance(args, str) else subprocess.list2cmdline(args)
+        si = api.STARTUPINFOW()
+        si.cb = ctypes.sizeof(si)
+        si.lpDesktop = lpdesktop(self._answer42_desktop)
+        use_std_handles = -1 not in (p2cread, c2pwrite, errwrite)
+        if use_std_handles:
+            si.dwFlags |= _STARTF_USESTDHANDLES
+            si.hStdInput = int(p2cread)
+            si.hStdOutput = int(c2pwrite)
+            si.hStdError = int(errwrite)
+        pi = api.PROCESS_INFORMATION()
+        env_block = _environment_block(env)
+        flags = int(creationflags) | (_CREATE_UNICODE_ENVIRONMENT if env_block is not None else 0)
+        cmd_buffer = ctypes.create_unicode_buffer(command_line)
+        try:
+            ok = api.kernel32.CreateProcessW(
+                executable, cmd_buffer, None, None, bool(use_std_handles), flags,
+                env_block, os.fspath(cwd) if cwd is not None else None,
+                ctypes.byref(si), ctypes.byref(pi),
+            )
+            if not ok:
+                raise _last_error(api, "CreateProcessW")
+        finally:
+            # Same as CPython: drop the parent's copies of child-only handles.
+            self._close_pipe_fds(p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite)
+        api.kernel32.CloseHandle(pi.hThread)
+        self._child_created = True
+        self._handle = subprocess.Handle(pi.hProcess)
+        self.pid = int(pi.dwProcessId)

{answer42-0.5.2 → answer42-0.5.4}/src/mcp_1c/window_control.py

@@ -11,6 +11,8 @@ import time
 from dataclasses import dataclass
 from typing import Any
 
+from . import win_desktop
+
 LOGGER = logging.getLogger(__name__)
 
 TEST_CLIENT_WINDOW_TITLE = "Клиент тестирования (1С:Предприятие)"
@@ -48,7 +50,7 @@ def maximize_test_client_window(
     This function controls only window geometry; it doesn't click or type in the application.
     """
     if os.name == "nt":
-        return _maximize_with_winapi(title_contains, width, height).as_dict()
+        return _maximize_with_winapi(title_contains, width, height, desktop=display or "").as_dict()
 
     env = os.environ.copy()
     if display:
@@ -70,7 +72,7 @@ def active_1c_window_geometry(title_contains: str = "", display: str | None = No
     type, or decide whether a 1C UI command succeeded; UI automation goes
     through the 1C test-client API.
     """
-    chosen = _find_windows_1c_window(title_contains) if os.name == "nt" else _find_x11_1c_window(title_contains, display)
+    chosen = _find_windows_1c_window(title_contains, desktop=display or "") if os.name == "nt" else _find_x11_1c_window(title_contains, display)
     if not chosen:
         return None
     return chosen.get("geometry")
@@ -398,7 +400,10 @@ def _maximize_with_xlib(title_contains: str, display: str, width: int | None, he
         return WindowControlResult(False, "xlib", error=str(e))
 
 
-def _find_windows_1c_window(title_contains: str = "") -> dict[str, Any] | None:
+def _find_windows_1c_window(title_contains: str = "", desktop: str = "") -> dict[str, Any] | None:
+    """Find the best 1C window on the current desktop or an Answer42 hidden desktop."""
+    if win_desktop.is_hidden_desktop_name(desktop):
+        return _find_hidden_desktop_1c_window(title_contains, desktop)
     user32 = ctypes.windll.user32
     candidates: list[dict[str, Any]] = []
 
@@ -448,17 +453,73 @@ def _find_windows_1c_window(title_contains: str = "") -> dict[str, Any] | None:
     return candidates[0]
 
 
-def _maximize_with_winapi(title_contains: str, width: int | None, height: int | None) -> WindowControlResult:
+def _window_priority(title: str, width: int, height: int) -> int:
+    priority = min(width * height // 10000, 50)
+    if "1С:Предприятие" in title:
+        priority += 50
+    if title and title not in {"1cv8c", "1cv8", "Конфигурация"}:
+        priority += 100
+    return priority
+
+
+def _find_hidden_desktop_1c_window(title_contains: str, desktop: str) -> dict[str, Any] | None:
+    try:
+        windows = win_desktop.list_windows(desktop)
+    except OSError as exc:
+        LOGGER.debug("Cannot enumerate hidden desktop %s: %s", desktop, exc)
+        return None
+    # A hidden desktop holds only one Answer42 session role, so without an
+    # explicit filter any large window there is ours: the Windows caption of
+    # the test client is often just "Конфигурация".
+    title_filter_matches = any(_title_matches(str(w.get("title") or ""), title_contains) for w in windows)
+    candidates: list[dict[str, Any]] = []
+    for item in windows:
+        title = str(item.get("title") or "")
+        width, height = int(item["width"]), int(item["height"])
+        if width < 300 or height < 150:
+            continue
+        if (title_contains or title_filter_matches) and not _title_matches(title, title_contains):
+            continue
+        candidates.append({
+            "hwnd": int(item["hwnd"]),
+            "title": title,
+            "priority": _window_priority(title, width, height),
+            "geometry": {
+                "left": int(item["left"]),
+                "top": int(item["top"]),
+                "width": width,
+                "height": height,
+                "title": title,
+                "hwnd": int(item["hwnd"]),
+                "desktop": desktop,
+            },
+        })
+    if not candidates:
+        return None
+    candidates.sort(key=lambda item: int(item.get("priority") or 0), reverse=True)
+    return candidates[0]
+
+
+def _maximize_with_winapi(title_contains: str, width: int | None, height: int | None, desktop: str = "") -> WindowControlResult:
     try:
         import ctypes.wintypes  # type: ignore
 
         user32 = ctypes.windll.user32
-        chosen = _find_windows_1c_window(title_contains)
+        chosen = _find_windows_1c_window(title_contains, desktop=desktop)
         if chosen is None:
             return WindowControlResult(False, "winapi", error="window not found")
         hwnd = int(chosen["hwnd"])
         screen_w = width or user32.GetSystemMetrics(0) or 1920
         screen_h = height or user32.GetSystemMetrics(1) or 1080
+        if win_desktop.is_hidden_desktop_name(desktop):
+            win_desktop.maximize_window(desktop, hwnd, int(screen_w), int(screen_h))
+            return WindowControlResult(
+                True,
+                "winapi-hidden-desktop",
+                title=str(chosen.get("title") or ""),
+                geometry={"x": 0, "y": 0, "width": int(screen_w), "height": int(screen_h)},
+                candidates=[{"title": str(chosen.get("title") or ""), "hwnd": hwnd, "desktop": desktop}],
+            )
         user32.ShowWindow(hwnd, 9)  # SW_RESTORE
         user32.MoveWindow(hwnd, 0, 0, int(screen_w), int(screen_h), True)
         user32.ShowWindow(hwnd, 3)  # SW_MAXIMIZE