indesign-cli 0.2.0__py3-none-any.whl

cli_anything/indesign/core/envelope.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any
+
+from .errors import CliError
+
+
+def request_id() -> str:
+    return uuid.uuid4().hex[:16]
+
+
+def success(
+    *,
+    command: str,
+    data: Any,
+    duration_ms: int,
+    tool_id: str | None = None,
+    domain: str | None = None,
+    source: str | None = None,
+    backend: str | None = None,
+    warnings: list[str] | None = None,
+) -> dict[str, Any]:
+    return {
+        "schema_version": 1,
+        "ok": True,
+        "exit_code": 0,
+        "request_id": request_id(),
+        "command": command,
+        "tool_id": tool_id,
+        "domain": domain,
+        "source": source,
+        "backend": backend,
+        "mcp_ok": True,
+        "tool_success": True,
+        "raw_result_type": "json",
+        "duration_ms": duration_ms,
+        "data": data,
+        "warnings": warnings or [],
+    }
+
+
+def failure(*, command: str, error: CliError, duration_ms: int) -> dict[str, Any]:
+    return {
+        "schema_version": 1,
+        "ok": False,
+        "exit_code": 1,
+        "request_id": request_id(),
+        "command": command,
+        "duration_ms": duration_ms,
+        "error": {
+            "type": error.__class__.__name__,
+            "code": error.code,
+            "message": error.message,
+            "details": error.details,
+            "retryable": error.retryable,
+            "hint": error.hint,
+        },
+        "warnings": [],
+    }
+
+
+def now_ms() -> int:
+    return int(time.perf_counter() * 1000)

cli_anything/indesign/core/errors.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+
+class CliError(Exception):
+    def __init__(
+        self,
+        message: str,
+        *,
+        code: str = "CLI_ERROR",
+        retryable: bool = False,
+        details: dict | None = None,
+        hint: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.code = code
+        self.retryable = retryable
+        self.details = details or {}
+        self.hint = hint
+
+
+class TimeoutError(CliError):
+    def __init__(self, message: str, *, details: dict | None = None) -> None:
+        super().__init__(
+            message,
+            code="TIMEOUT",
+            retryable=True,
+            details=details,
+            hint="缩短脚本或增加 --timeout；若 InDesign 卡住，先检查应用窗口状态。",
+        )

cli_anything/indesign/core/health.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+def health(repo_root: Path, deep: bool = False) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "deep": deep,
+        "node": {"available": shutil.which("node") is not None},
+        "python": {"available": shutil.which("python") is not None},
+        "node_entry_advanced": {
+            "path": "src/advanced/index.js",
+            "exists": (repo_root / "src/advanced/index.js").exists(),
+        },
+        "node_entry_classic": {
+            "path": "src/index.js",
+            "exists": (repo_root / "src/index.js").exists(),
+        },
+    }
+    if deep:
+        payload["winax"] = _check_winax(repo_root)
+        payload["indesign_com"] = {
+            "checked": False,
+            "available": None,
+            "reason": "health --deep 不主动连接 COM，避免隐式启动或干扰 InDesign；真实验证请运行 INDESIGN_E2E=1 的 E2E 测试。",
+        }
+    return payload
+
+
+def _check_winax(repo_root: Path) -> dict[str, Any]:
+    try:
+        result = subprocess.run(
+            ["node", "-e", "require('winax'); process.stdout.write('ok')"],
+            cwd=repo_root,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=10,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return {"checked": True, "available": False}
+    return {"checked": True, "available": result.returncode == 0}

cli_anything/indesign/core/hidden_backend.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from .errors import CliError, TimeoutError
+from .hidden_handler_schemas import HIDDEN_HANDLER_SCHEMAS
+from .paths import scrub_text_paths
+from .runtime import hidden_handler_bridge_path
+
+
+class HiddenHandlerBackend:
+    def __init__(self, repo_root: Path, timeout_seconds: int = 60) -> None:
+        self.repo_root = repo_root
+        self.timeout_seconds = timeout_seconds
+
+    def schema(self, tool_id: str) -> dict[str, Any]:
+        try:
+            return HIDDEN_HANDLER_SCHEMAS[tool_id]
+        except KeyError as exc:
+            raise CliError(f"Hidden handler schema missing: {tool_id}", code="SCHEMA_NOT_FOUND") from exc
+
+    def call_tool(self, tool: dict[str, Any], arguments: dict[str, Any]) -> dict[str, Any]:
+        schema = self.schema(tool["id"])
+        self._validate_required(schema, arguments)
+
+        bridge = hidden_handler_bridge_path()
+
+        request = {
+            "domain": tool["domain"],
+            "name": tool["name"],
+            "args": arguments,
+        }
+        try:
+            proc = subprocess.run(
+                ["node", str(bridge)],
+                cwd=self.repo_root,
+                env={**os.environ, "INDESIGN_CLI_SERVER_ROOT": str(self.repo_root)},
+                input=json.dumps(request, ensure_ascii=False),
+                text=True,
+                encoding="utf-8",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                check=False,
+                timeout=self.timeout_seconds,
+            )
+        except subprocess.TimeoutExpired as exc:
+            raise TimeoutError(
+                "Hidden handler bridge timed out",
+                details={"tool": tool["id"], "stderr_tail": scrub_text_paths((exc.stderr or "")[-2000:])},
+            ) from exc
+        except OSError as exc:
+            raise CliError("Failed to start hidden handler bridge", code="HIDDEN_HANDLER_START_FAILED") from exc
+
+        payload = self._parse_bridge_payload(proc, tool["id"])
+        if not payload.get("ok"):
+            error = payload.get("error", {})
+            raise CliError(
+                "Hidden handler bridge failed",
+                code=error.get("code", "HIDDEN_HANDLER_FAILED"),
+                details={
+                    "tool": tool["id"],
+                    "message": scrub_text_paths(str(error.get("message", ""))),
+                },
+            )
+
+        result = payload.get("result", {})
+        if isinstance(result, dict) and result.get("success") is False:
+            raise CliError(
+                "Hidden handler failed",
+                code="HIDDEN_HANDLER_FAILED",
+                details={"tool": tool["id"], "operation": result.get("operation")},
+            )
+        if isinstance(result, dict) and isinstance(result.get("result"), str) and result["result"].startswith("Error:"):
+            raise CliError(
+                "Hidden handler failed",
+                code="HIDDEN_HANDLER_FAILED",
+                details={
+                    "tool": tool["id"],
+                    "operation": result.get("operation"),
+                    "result": scrub_text_paths(result["result"]),
+                },
+            )
+        return result
+
+    def _parse_bridge_payload(self, proc: subprocess.CompletedProcess[str], tool_id: str) -> dict[str, Any]:
+        stderr_tail = scrub_text_paths((proc.stderr or "")[-2000:])
+        if proc.returncode != 0:
+            raise CliError(
+                "Hidden handler bridge exited with an error",
+                code="HIDDEN_HANDLER_BRIDGE_FAILED",
+                details={"tool": tool_id, "returncode": proc.returncode, "stderr_tail": stderr_tail},
+            )
+
+        stdout = (proc.stdout or "").strip()
+        try:
+            payload = json.loads(stdout)
+        except json.JSONDecodeError as exc:
+            raise CliError(
+                "Hidden handler bridge response is not JSON",
+                code="HIDDEN_HANDLER_BAD_JSON",
+                details={"tool": tool_id, "stdout": scrub_text_paths(stdout[-1000:]), "stderr_tail": stderr_tail},
+            ) from exc
+        if not isinstance(payload, dict):
+            raise CliError("Hidden handler bridge response must be an object", code="HIDDEN_HANDLER_BAD_JSON")
+        return payload
+
+    @staticmethod
+    def _validate_required(schema: dict[str, Any], arguments: dict[str, Any]) -> None:
+        for key in schema.get("required", []):
+            value = arguments.get(key)
+            if value in (None, ""):
+                raise CliError(f"Missing required argument: {key}", code="MISSING_ARGUMENT", details={"argument": key})

cli_anything/indesign/core/hidden_handler_schemas.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def _object_schema(properties: dict[str, dict[str, Any]], required: list[str] | None = None) -> dict[str, Any]:
+    schema: dict[str, Any] = {
+        "type": "object",
+        "additionalProperties": False,
+        "properties": properties,
+    }
+    if required:
+        schema["required"] = required
+    return schema
+
+
+def _string(description: str) -> dict[str, Any]:
+    return {"type": "string", "description": description}
+
+
+def _number(description: str, *, minimum: int | float | None = None) -> dict[str, Any]:
+    schema: dict[str, Any] = {"type": "number", "description": description}
+    if minimum is not None:
+        schema["minimum"] = minimum
+    return schema
+
+
+def _boolean(description: str, default: bool | None = None) -> dict[str, Any]:
+    schema: dict[str, Any] = {"type": "boolean", "description": description}
+    if default is not None:
+        schema["default"] = default
+    return schema
+
+
+BOOK_PATH = _string("InDesign Book 文件路径，通常为 .indb")
+DOCUMENT_PATH = _string("要加入 Book 的 InDesign 文档路径，通常为 .indd")
+OUTPUT_PATH = _string("输出文件或输出目录路径")
+
+BOOK_SYNC_PROPERTIES = {
+    "automaticPagination": _boolean("是否启用自动页码"),
+    "automaticDocumentConversion": _boolean("是否启用自动文档转换"),
+    "insertBlankPage": _boolean("是否插入空白页"),
+    "mergeIdenticalLayers": _boolean("是否合并同名图层"),
+    "synchronizeBulletNumberingList": _boolean("是否同步项目符号和编号列表"),
+    "synchronizeCellStyle": _boolean("是否同步单元格样式"),
+    "synchronizeCharacterStyle": _boolean("是否同步字符样式"),
+    "synchronizeConditionalText": _boolean("是否同步条件文本"),
+    "synchronizeCrossReferenceFormat": _boolean("是否同步交叉引用格式"),
+    "synchronizeMasterPage": _boolean("是否同步主页"),
+    "synchronizeObjectStyle": _boolean("是否同步对象样式"),
+    "synchronizeParagraphStyle": _boolean("是否同步段落样式"),
+    "synchronizeSwatch": _boolean("是否同步色板"),
+    "synchronizeTableOfContentStyle": _boolean("是否同步目录样式"),
+    "synchronizeTableStyle": _boolean("是否同步表格样式"),
+    "synchronizeTextVariable": _boolean("是否同步文本变量"),
+    "synchronizeTrapStyle": _boolean("是否同步陷印样式"),
+}
+
+HIDDEN_HANDLER_SCHEMAS: dict[str, dict[str, Any]] = {
+    "book.create_book": _object_schema(
+        {"filePath": BOOK_PATH},
+        ["filePath"],
+    ),
+    "book.open_book": _object_schema(
+        {"filePath": BOOK_PATH},
+        ["filePath"],
+    ),
+    "book.add_document_to_book": _object_schema(
+        {
+            "bookPath": BOOK_PATH,
+            "documentPath": DOCUMENT_PATH,
+        },
+        ["bookPath", "documentPath"],
+    ),
+    "book.synchronize_book": _object_schema(
+        {"bookPath": BOOK_PATH},
+        ["bookPath"],
+    ),
+    "book.export_book": _object_schema(
+        {
+            "bookPath": BOOK_PATH,
+            "outputPath": OUTPUT_PATH,
+            "format": {
+                "type": "string",
+                "enum": ["PDF", "EPUB", "HTML"],
+                "default": "PDF",
+                "description": "导出格式",
+            },
+        },
+        ["bookPath", "outputPath"],
+    ),
+    "book.package_book": _object_schema(
+        {
+            "bookPath": BOOK_PATH,
+            "outputPath": OUTPUT_PATH,
+            "copyingFonts": _boolean("是否复制字体", True),
+            "copyingLinkedGraphics": _boolean("是否复制链接图像", True),
+            "copyingProfiles": _boolean("是否复制色彩配置文件", True),
+            "updatingGraphics": _boolean("是否更新图像链接", True),
+            "includingHiddenLayers": _boolean("是否包含隐藏图层", False),
+            "ignorePreflightErrors": _boolean("是否忽略预检错误", False),
+            "creatingReport": _boolean("是否创建打包报告", True),
+            "includeIdml": _boolean("是否包含 IDML", False),
+            "includePdf": _boolean("是否包含 PDF", False),
+        },
+        ["bookPath", "outputPath"],
+    ),
+    "book.get_book_info": _object_schema(
+        {"bookPath": BOOK_PATH},
+        ["bookPath"],
+    ),
+    "book.list_books": _object_schema({}),
+    "book.repaginate_book": _object_schema(
+        {"bookPath": BOOK_PATH},
+        ["bookPath"],
+    ),
+    "book.update_all_cross_references": _object_schema(
+        {"bookPath": BOOK_PATH},
+        ["bookPath"],
+    ),
+    "book.update_all_numbers": _object_schema(
+        {"bookPath": BOOK_PATH},
+        ["bookPath"],
+    ),
+    "book.update_chapter_and_paragraph_numbers": _object_schema(
+        {"bookPath": BOOK_PATH},
+        ["bookPath"],
+    ),
+    "book.preflight_book": _object_schema(
+        {
+            "bookPath": BOOK_PATH,
+            "outputPath": OUTPUT_PATH,
+            "autoOpen": _boolean("生成预检报告后是否自动打开", False),
+        },
+        ["bookPath"],
+    ),
+    "book.print_book": _object_schema(
+        {
+            "bookPath": BOOK_PATH,
+            "printDialog": _boolean("是否显示打印对话框", True),
+            "printerPreset": {
+                "type": "string",
+                "default": "DEFAULT_VALUE",
+                "description": "InDesign PrinterPresetTypes 枚举名",
+            },
+        },
+        ["bookPath"],
+    ),
+    "book.set_book_properties": _object_schema(
+        {"bookPath": BOOK_PATH, **BOOK_SYNC_PROPERTIES},
+        ["bookPath"],
+    ),
+    "presentation.create_presentation_document": _object_schema(
+        {
+            "preset": {
+                "type": "string",
+                "enum": ["A3_LANDSCAPE", "A4_LANDSCAPE", "RATIO_16x9"],
+                "default": "A3_LANDSCAPE",
+                "description": "演示文稿页面尺寸预设",
+            },
+            "width": _number("自定义页面宽度，单位 mm", minimum=1),
+            "height": _number("自定义页面高度，单位 mm", minimum=1),
+            "pages": {
+                "type": "integer",
+                "minimum": 1,
+                "default": 1,
+                "description": "初始页数",
+            },
+            "facingPages": _boolean("是否启用对页", False),
+        },
+    ),
+    "presentation.add_cover_page": _object_schema(
+        {
+            "title": _string("封面标题"),
+            "subtitle": _string("封面副标题"),
+            "bgImagePath": _string("封面背景图片路径"),
+        },
+    ),
+    "presentation.add_section_page": _object_schema(
+        {"title": _string("章节页标题")},
+    ),
+    "presentation.add_full_bleed_image": _object_schema(
+        {
+            "filePath": _string("要铺满当前页的图片路径"),
+            "caption": _string("可选图片说明"),
+        },
+        ["filePath"],
+    ),
+    "presentation.add_image_grid": _object_schema(
+        {
+            "files": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "要置入网格的图片路径列表",
+            },
+            "rows": {
+                "type": "integer",
+                "minimum": 1,
+                "default": 2,
+                "description": "网格行数",
+            },
+            "columns": {
+                "type": "integer",
+                "minimum": 1,
+                "default": 3,
+                "description": "网格列数",
+            },
+            "gap": _number("网格间距，单位与文档标尺一致", minimum=0),
+        },
+        ["files"],
+    ),
+    "presentation.export_presentation_pdf": _object_schema(
+        {
+            "filePath": _string("PDF 输出路径"),
+            "preset": {
+                "type": "string",
+                "default": "High Quality Print",
+                "description": "InDesign PDF 导出预设名称",
+            },
+        },
+        ["filePath"],
+    ),
+}

cli_anything/indesign/core/mcp_backend.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import threading
+from pathlib import Path
+from typing import Any, Callable
+
+from .errors import CliError, TimeoutError
+from .paths import scrub_text_paths
+
+
+class McpBackend:
+    def __init__(self, repo_root: Path, entry: str, timeout_seconds: int = 30) -> None:
+        self.repo_root = repo_root
+        self.entry = entry
+        self.timeout_seconds = timeout_seconds
+        self._next_id = 1
+
+    def list_tools(self) -> list[dict[str, Any]]:
+        response = self._with_process(lambda proc: self._request(proc, "tools/list", {}))
+        return response.get("tools", [])
+
+    def call_tool(self, name: str, arguments: dict[str, Any]) -> dict[str, Any]:
+        response = self._with_process(
+            lambda proc: self._request(proc, "tools/call", {"name": name, "arguments": arguments})
+        )
+        return self._parse_tool_response(name, response)
+
+    def _with_process(self, action: Callable[[subprocess.Popen[str]], dict[str, Any]]) -> dict[str, Any]:
+        entry_path = self.repo_root / self.entry
+        if not entry_path.exists():
+            raise CliError(f"MCP entry not found: {self.entry}", code="MCP_ENTRY_NOT_FOUND")
+
+        try:
+            proc = subprocess.Popen(
+                ["node", self.entry],
+                cwd=self.repo_root,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                encoding="utf-8",
+            )
+        except OSError as exc:
+            raise CliError("Failed to start MCP process", code="MCP_START_FAILED", details={"entry": self.entry}) from exc
+
+        timed_out = {"value": False}
+        stderr_tail: list[str] = []
+
+        def drain_stderr() -> None:
+            if proc.stderr is None:
+                return
+            for line in proc.stderr:
+                stderr_tail.append(scrub_text_paths(line.strip()))
+                del stderr_tail[:-20]
+
+        def kill_process() -> None:
+            timed_out["value"] = True
+            proc.kill()
+
+        timer = threading.Timer(self.timeout_seconds, kill_process)
+        stderr_thread = threading.Thread(target=drain_stderr, daemon=True)
+        try:
+            timer.start()
+            stderr_thread.start()
+            self._request(
+                proc,
+                "initialize",
+                {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {},
+                    "clientInfo": {"name": "indesign-cli", "version": "0.2.0"},
+                },
+            )
+            self._notify(proc, "notifications/initialized", {})
+            return action(proc)
+        finally:
+            timer.cancel()
+            if proc.poll() is None:
+                proc.terminate()
+                try:
+                    proc.wait(timeout=3)
+                except subprocess.TimeoutExpired:
+                    proc.kill()
+            if timed_out["value"]:
+                raise TimeoutError("MCP process timed out", details={"entry": self.entry, "stderr_tail": stderr_tail})
+
+    def _request(self, proc: subprocess.Popen[str], method: str, params: dict[str, Any]) -> dict[str, Any]:
+        if proc.stdin is None or proc.stdout is None:
+            raise CliError("MCP process stdio is unavailable", code="MCP_STDIO_UNAVAILABLE")
+        request = {"jsonrpc": "2.0", "id": self._next_id, "method": method, "params": params}
+        self._next_id += 1
+        proc.stdin.write(json.dumps(request, ensure_ascii=False) + "\n")
+        proc.stdin.flush()
+        line = proc.stdout.readline()
+        if line == "":
+            raise TimeoutError("MCP process ended before response", details={"method": method, "entry": self.entry})
+        try:
+            response = json.loads(line)
+        except json.JSONDecodeError as exc:
+            raise CliError("MCP response is not JSON", code="MCP_BAD_JSON", details={"line": line[:500]}) from exc
+        if "error" in response:
+            raise CliError(
+                response["error"].get("message", "MCP request failed"),
+                code="MCP_PROTOCOL_ERROR",
+                retryable=False,
+                details=response["error"],
+            )
+        return response.get("result", {})
+
+    def _notify(self, proc: subprocess.Popen[str], method: str, params: dict[str, Any]) -> None:
+        if proc.stdin is None:
+            raise CliError("MCP process stdin is unavailable", code="MCP_STDIN_UNAVAILABLE")
+        proc.stdin.write(json.dumps({"jsonrpc": "2.0", "method": method, "params": params}) + "\n")
+        proc.stdin.flush()
+
+    def _parse_tool_response(self, name: str, response: dict[str, Any]) -> dict[str, Any]:
+        content = response.get("content", [])
+        if not content:
+            return response
+
+        first = content[0]
+        if first.get("type") != "text":
+            return response
+
+        text = first.get("text", "")
+        try:
+            parsed = json.loads(text)
+        except json.JSONDecodeError:
+            if response.get("isError"):
+                raise CliError(
+                    "MCP tool failed",
+                    code="MCP_TOOL_FAILED",
+                    details={"tool": name, "result": scrub_text_paths(text)},
+                )
+            return response
+
+        if response.get("isError") or (isinstance(parsed, dict) and parsed.get("success") is False):
+            details = {"tool": name}
+            if isinstance(parsed, dict):
+                details["operation"] = parsed.get("operation")
+                details["result"] = scrub_text_paths(str(parsed.get("result", "")))
+            raise CliError("MCP tool failed", code="MCP_TOOL_FAILED", details=details)
+
+        payload = {"content": content, "parsed": parsed}
+        if isinstance(parsed, dict) and isinstance(parsed.get("result"), str):
+            try:
+                payload["result_json"] = json.loads(parsed["result"])
+            except json.JSONDecodeError:
+                pass
+        return payload

cli_anything/indesign/core/node_setup.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from .errors import CliError
+from .paths import scrub_text_paths
+
+
+def setup_node_dependencies(server_root: Path) -> dict[str, Any]:
+    try:
+        result = subprocess.run(
+            ["npm", "install"],
+            cwd=server_root,
+            text=True,
+            encoding="utf-8",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=False,
+            timeout=180,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        raise CliError("Failed to install Node dependencies", code="NPM_INSTALL_FAILED") from exc
+
+    payload = {
+        "ok": result.returncode == 0,
+        "server_root": str(server_root),
+        "returncode": result.returncode,
+        "stdout_tail": scrub_text_paths((result.stdout or "")[-2000:]),
+        "stderr_tail": scrub_text_paths((result.stderr or "")[-2000:]),
+    }
+    if result.returncode != 0:
+        raise CliError("npm install failed", code="NPM_INSTALL_FAILED", details=payload)
+    return payload