indesign-cli 0.2.0__py3-none-any.whl

cli_anything/indesign/core/plugins/validate.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from ..errors import CliError
+from .backend import PluginBackend
+from .discovery import discover_plugins
+from .manifest import (
+    TOOL_ID_PATTERN,
+    PluginRecord,
+    load_plugin_record,
+    validate_manifest,
+)
+
+
+REQUIRED_TOOL_FIELDS = {
+    "id",
+    "domain",
+    "name",
+    "one_line_purpose",
+    "arg_names",
+    "rank",
+    "schema_size",
+    "callable",
+    "requires",
+    "side_effects",
+    "artifact_kinds",
+    "destructive",
+    "target_scope",
+    "needs_indesign",
+    "produces_artifacts",
+}
+
+
+def _error(code: str, message: str, **details: Any) -> dict[str, Any]:
+    return {"code": code, "message": message, "details": details}
+
+
+def _schema_errors(tool: dict[str, Any], schema_payload: dict[str, Any]) -> list[dict[str, Any]]:
+    errors: list[dict[str, Any]] = []
+    schema = schema_payload.get("inputSchema")
+    tool_id = str(tool.get("id"))
+    if not isinstance(schema, dict):
+        return [_error("PLUGIN_SCHEMA_INVALID", "inputSchema must be an object", tool_id=tool_id)]
+    if schema.get("type") != "object":
+        errors.append(_error("PLUGIN_SCHEMA_INVALID", "inputSchema.type must be object", tool_id=tool_id))
+    properties = schema.get("properties")
+    if not isinstance(properties, dict):
+        errors.append(_error("PLUGIN_SCHEMA_INVALID", "inputSchema.properties must be an object", tool_id=tool_id))
+        properties = {}
+    for arg_name in tool.get("arg_names", []):
+        if arg_name not in properties:
+            errors.append(_error("PLUGIN_SCHEMA_INVALID", "arg_names must match inputSchema.properties", tool_id=tool_id, argument=arg_name))
+    for required in schema.get("required", []):
+        if required not in properties:
+            errors.append(_error("PLUGIN_SCHEMA_INVALID", "required argument missing from properties", tool_id=tool_id, argument=required))
+    return errors
+
+
+def _tool_errors(record: PluginRecord, tool: dict[str, Any]) -> list[dict[str, Any]]:
+    errors: list[dict[str, Any]] = []
+    missing = sorted(field for field in REQUIRED_TOOL_FIELDS if field not in tool)
+    for field in missing:
+        errors.append(_error("PLUGIN_TOOL_INVALID", "Missing tool field", tool_id=tool.get("id"), field=field))
+    if missing:
+        return errors
+    tool_id = tool["id"]
+    if not isinstance(tool_id, str) or not TOOL_ID_PATTERN.match(tool_id):
+        errors.append(_error("PLUGIN_TOOL_INVALID", "Invalid tool id", tool_id=tool_id))
+    elif not tool_id.startswith(f"{record.domain}."):
+        errors.append(_error("PLUGIN_TOOL_INVALID", "Tool id must use plugin domain", tool_id=tool_id, domain=record.domain))
+    if tool.get("domain") != record.domain:
+        errors.append(_error("PLUGIN_TOOL_INVALID", "Tool domain must match plugin domain", tool_id=tool_id, domain=tool.get("domain")))
+    for list_field in ("arg_names", "requires", "side_effects", "artifact_kinds"):
+        if not isinstance(tool.get(list_field), list):
+            errors.append(_error("PLUGIN_TOOL_INVALID", f"{list_field} must be an array", tool_id=tool_id))
+    for bool_field in ("callable", "destructive", "needs_indesign", "produces_artifacts"):
+        if not isinstance(tool.get(bool_field), bool):
+            errors.append(_error("PLUGIN_TOOL_INVALID", f"{bool_field} must be boolean", tool_id=tool_id))
+    return errors
+
+
+def validate_plugin_path(path_value: str, *, host_version: str) -> dict[str, Any]:
+    errors: list[dict[str, Any]] = []
+    warnings: list[dict[str, Any]] = []
+    try:
+        record = load_plugin_record(Path(path_value), source="validate", host_version=host_version)
+    except CliError as exc:
+        manifest_errors = exc.details.get("errors") if isinstance(exc.details.get("errors"), list) else None
+        errors.extend(manifest_errors or [_error(exc.code, exc.message, **exc.details)])
+        return {"ok": False, "plugin": None, "errors": errors, "warnings": warnings, "summary": {}}
+
+    manifest_errors = validate_manifest(
+        manifest=record.manifest,
+        root=record.root,
+        manifest_path=record.manifest_path,
+        host_version=host_version,
+    )
+    errors.extend(manifest_errors)
+    if errors:
+        return {"ok": False, "plugin": record.id, "errors": errors, "warnings": warnings, "summary": {}}
+
+    backend = PluginBackend(record)
+    tools: list[dict[str, Any]] = []
+    try:
+        handshake = backend.handshake({"name": "indesign-cli", "version": host_version, "protocol": "indesign-cli-plugin.v1"})
+        if handshake.get("id") != record.id:
+            errors.append(_error("PLUGIN_HANDSHAKE_FAILED", "Handshake id does not match manifest", expected=record.id, actual=handshake.get("id")))
+        if handshake.get("protocol") != record.manifest["protocol"]:
+            errors.append(_error("PLUGIN_HANDSHAKE_FAILED", "Handshake protocol does not match manifest", expected=record.manifest["protocol"], actual=handshake.get("protocol")))
+        tools = backend.list_tools()
+    except CliError as exc:
+        errors.append(_error(exc.code, exc.message, **exc.details))
+
+    for tool in tools:
+        errors.extend(_tool_errors(record, tool))
+        if tool.get("callable") and isinstance(tool.get("id"), str):
+            try:
+                schema_payload = backend.schema(tool["id"])
+            except CliError as exc:
+                errors.append(_error(exc.code, exc.message, tool_id=tool["id"], **exc.details))
+                continue
+            errors.extend(_schema_errors(tool, schema_payload))
+
+    return {
+        "ok": not errors,
+        "plugin": record.id,
+        "errors": errors,
+        "warnings": warnings,
+        "summary": {
+            "tools": len(tools),
+            "needs_indesign": sum(1 for tool in tools if tool.get("needs_indesign")),
+            "host_actions": record.manifest.get("capabilities", {}).get("host_actions", []),
+        },
+    }
+
+
+def doctor_plugin(plugin_id: str, *, cwd: Path, host_version: str, deep: bool = False) -> dict[str, Any]:
+    records, discovery_warnings = discover_plugins(cwd, host_version=host_version)
+    record = next((item for item in records if item.id == plugin_id), None)
+    if not record:
+        raise CliError("Plugin is not installed", code="PLUGIN_NOT_INSTALLED", details={"id": plugin_id})
+
+    checks: list[dict[str, Any]] = []
+    checks.append({"name": "discovered", "ok": True, "source": record.source})
+    session_dir = cwd / ".indesign-cli"
+    try:
+        session_dir.mkdir(parents=True, exist_ok=True)
+        probe = session_dir / ".doctor-write-test"
+        probe.write_text("ok", encoding="utf-8")
+        probe.unlink()
+        checks.append({"name": "session_writable", "ok": True})
+    except OSError as exc:
+        checks.append({"name": "session_writable", "ok": False, "message": str(exc)})
+
+    node = shutil.which("node")
+    checks.append({"name": "node_available", "ok": node is not None, "path": node})
+    if node:
+        completed = subprocess.run(["node", "--version"], text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
+        checks.append({"name": "node_version", "ok": completed.returncode == 0, "version": completed.stdout.strip()})
+
+    validate_payload = validate_plugin_path(str(record.root), host_version=host_version)
+    checks.append({"name": "validate", "ok": validate_payload["ok"], "errors": validate_payload["errors"]})
+
+    try:
+        plugin_doctor = PluginBackend(record).doctor()
+        checks.append({"name": "plugin_doctor", "ok": bool(plugin_doctor.get("ok", True)), "data": plugin_doctor})
+    except CliError as exc:
+        checks.append({"name": "plugin_doctor", "ok": False, "code": exc.code, "message": exc.message})
+
+    return {
+        "ok": all(check.get("ok") is True for check in checks),
+        "plugin": record.id,
+        "source": record.source,
+        "deep": deep,
+        "checks": checks,
+        "warnings": discovery_warnings,
+    }

cli_anything/indesign/core/router.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import json
+import sys
+from json import JSONDecodeError
+from pathlib import Path
+from typing import Any
+
+from .catalog import Catalog
+from .errors import CliError
+from .hidden_backend import HiddenHandlerBackend
+from .mcp_backend import McpBackend
+from .plugins.backend import PluginBackend
+from .plugins.host_actions import ALLOWED_HOST_ACTIONS, HostActionExecutor
+
+
+BACKENDS = {
+    "advanced": "src/advanced/index.js",
+    "classic": "src/index.js",
+}
+
+
+PRIMITIVE_SCHEMAS = {
+    "export.verify": {
+        "type": "object",
+        "additionalProperties": False,
+        "properties": {
+            "path": {"type": "string", "description": "要验证的 PDF 或 IDML 路径"},
+            "created_after": {"type": "string", "description": "ISO 时间戳；用于避免验证到旧产物"},
+        },
+        "required": ["path"],
+    },
+    "server.health": {
+        "type": "object",
+        "additionalProperties": False,
+        "properties": {
+            "deep": {"type": "boolean", "description": "是否执行较深的依赖检查"},
+        },
+    },
+    "server.setup": {"type": "object", "additionalProperties": False, "properties": {}},
+    "session.show": {
+        "type": "object",
+        "additionalProperties": False,
+        "properties": {
+            "verbose": {"type": "boolean", "description": "是否显示允许展示的详细 session 信息"},
+        },
+    },
+    "session.clear": {"type": "object", "additionalProperties": False, "properties": {}},
+    "script.run": {
+        "type": "object",
+        "additionalProperties": False,
+        "properties": {
+            "file": {"type": "string", "description": "要执行的 JSX 文件路径"},
+            "stdin": {"type": "boolean", "description": "从 stdin 读取临时 JSX"},
+            "timeout": {"type": "integer", "description": "脚本通道超时秒数，范围 1-3600"},
+        },
+    },
+    "skill.install": {
+        "type": "object",
+        "additionalProperties": False,
+        "properties": {
+            "target": {"type": "string", "description": "目标项目根目录；默认使用当前工作目录"},
+        },
+    },
+}
+
+
+class Router:
+    def __init__(self, catalog: Catalog, repo_root: Path, backend_timeout_seconds: int | None = None) -> None:
+        self.catalog = catalog
+        self.repo_root = repo_root
+        self.backend_timeout_seconds = backend_timeout_seconds
+
+    def _find(self, tool_id: str) -> dict[str, Any]:
+        matches = [tool for tool in self.catalog.list_tools(callable_only=False) if tool["id"] == tool_id]
+        if not matches:
+            raise CliError(f"Tool not found: {tool_id}", code="TOOL_NOT_FOUND")
+        return matches[0]
+
+    def schema(self, tool_id: str) -> dict[str, Any]:
+        tool = self._find(tool_id)
+        if not tool["callable"]:
+            raise CliError(f"Tool is not callable: {tool_id}", code="TOOL_NOT_CALLABLE")
+        if tool["source"] in {"cli", "script"}:
+            return {"tool": tool, "inputSchema": PRIMITIVE_SCHEMAS.get(tool_id, {"type": "object", "properties": {}})}
+        if tool["source"] == "hidden_handler":
+            return {"tool": tool, "inputSchema": HiddenHandlerBackend(self.repo_root).schema(tool_id)}
+        if tool["source"] == "plugin":
+            backend = self._plugin_backend(tool)
+            payload = backend.schema(tool_id)
+            return {"tool": tool, "inputSchema": payload.get("inputSchema", {})}
+        backend = self._backend(tool["source"])
+        for item in backend.list_tools():
+            if item["name"] == tool["name"]:
+                return {"tool": tool, "inputSchema": item.get("inputSchema", {})}
+        raise CliError(f"Backend schema missing for {tool_id}", code="SCHEMA_NOT_FOUND")
+
+    def call(self, tool_id: str, args: dict[str, Any]) -> dict[str, Any]:
+        tool = self._find(tool_id)
+        if not tool["callable"]:
+            raise CliError(f"Tool is not callable: {tool_id}", code="TOOL_NOT_CALLABLE")
+        if tool["source"] == "cli":
+            return self._call_cli_primitive(tool_id, args)
+        if tool["source"] == "script":
+            return self._call_script_primitive(args)
+        if tool["source"] == "hidden_handler":
+            return HiddenHandlerBackend(self.repo_root).call_tool(tool, args)
+        if tool["source"] == "plugin":
+            backend = self._plugin_backend(tool)
+            result = backend.call_tool(tool_id, args, self._plugin_context())
+            return HostActionExecutor(self, Path.cwd()).complete(backend, tool_id, result)
+        if tool["source"] not in BACKENDS:
+            raise CliError(f"Tool is handled by a CLI command: {tool_id}", code="CLI_PRIMITIVE_ROUTE")
+        backend = self._backend(tool["source"])
+        return backend.call_tool(tool["name"], args)
+
+    def _backend(self, source: str) -> McpBackend:
+        try:
+            entry = BACKENDS[source]
+        except KeyError as exc:
+            raise CliError(f"Unsupported backend source: {source}", code="BACKEND_NOT_SUPPORTED") from exc
+        return McpBackend(repo_root=self.repo_root, entry=entry, timeout_seconds=self.backend_timeout_seconds or 30)
+
+    def _plugin_backend(self, tool: dict[str, Any]) -> PluginBackend:
+        plugin_id = tool.get("plugin")
+        if not isinstance(plugin_id, str) or not plugin_id:
+            raise CliError("Plugin tool is missing plugin id", code="PLUGIN_RECORD_NOT_FOUND", details={"tool_id": tool.get("id")})
+        return PluginBackend(self.catalog.plugin_record(plugin_id))
+
+    @staticmethod
+    def _plugin_context() -> dict[str, Any]:
+        cwd = Path.cwd()
+        return {
+            "cwd": str(cwd),
+            "session_path": str(cwd / ".indesign-cli" / "session.json"),
+            "host_tools": sorted(ALLOWED_HOST_ACTIONS),
+        }
+
+    def _call_cli_primitive(self, tool_id: str, args: dict[str, Any]) -> dict[str, Any]:
+        if tool_id == "export.verify":
+            from .artifacts import parse_timestamp, verify_artifact
+
+            path = self._require_arg(args, "path")
+            try:
+                created_after = parse_timestamp(args["created_after"]) if args.get("created_after") else None
+            except ValueError as exc:
+                raise CliError("created_after must be an ISO timestamp", code="BAD_TIMESTAMP") from exc
+            return verify_artifact(Path(path), created_after=created_after, cwd=Path.cwd())
+        if tool_id == "session.show":
+            from .session import SessionStore
+
+            return SessionStore(Path.cwd()).read(compact=not bool(args.get("verbose")))
+        if tool_id == "session.clear":
+            from .session import SessionStore
+
+            SessionStore(Path.cwd()).clear()
+            return {"cleared": True}
+        if tool_id == "server.health":
+            from .health import health
+
+            return health(self.repo_root, deep=bool(args.get("deep")))
+        if tool_id == "server.setup":
+            from .node_setup import setup_node_dependencies
+
+            return setup_node_dependencies(self.repo_root)
+        if tool_id == "skill.install":
+            from .runtime import install_skill
+
+            return install_skill(Path(args.get("target") or "."))
+        raise CliError(f"Unsupported CLI primitive: {tool_id}", code="CLI_PRIMITIVE_UNSUPPORTED")
+
+    def _call_script_primitive(self, args: dict[str, Any]) -> dict[str, Any]:
+        from .scripts import run_script, run_stdin_script
+
+        old_timeout = self.backend_timeout_seconds
+        if args.get("timeout") is not None:
+            self.backend_timeout_seconds = self._parse_timeout(args.get("timeout"))
+        try:
+            if args.get("stdin"):
+                return run_stdin_script(self, Path.cwd())
+            if args.get("file"):
+                return run_script(self, Path(args["file"]))
+            raise CliError("script.run requires file or stdin", code="SCRIPT_INPUT_REQUIRED")
+        finally:
+            self.backend_timeout_seconds = old_timeout
+
+    @staticmethod
+    def _require_arg(args: dict[str, Any], key: str) -> Any:
+        value = args.get(key)
+        if value in (None, ""):
+            raise CliError(f"Missing required argument: {key}", code="MISSING_ARGUMENT", details={"argument": key})
+        return value
+
+    @staticmethod
+    def _parse_timeout(value: Any) -> int:
+        try:
+            timeout = int(value)
+        except (TypeError, ValueError) as exc:
+            raise CliError("timeout must be an integer number of seconds", code="BAD_TIMEOUT") from exc
+        if timeout < 1 or timeout > 3600:
+            raise CliError("timeout must be between 1 and 3600 seconds", code="BAD_TIMEOUT", details={"timeout": timeout})
+        return timeout
+
+
+def load_args(path_value: str) -> dict[str, Any]:
+    try:
+        if path_value == "-":
+            payload = json.loads(sys.stdin.read() or "{}")
+        else:
+            payload = json.loads(Path(path_value).read_text(encoding="utf-8-sig"))
+    except FileNotFoundError as exc:
+        raise CliError("Arguments file not found", code="ARGS_FILE_NOT_FOUND") from exc
+    except JSONDecodeError as exc:
+        raise CliError("Arguments must be valid JSON", code="ARGS_JSON_INVALID") from exc
+    if not isinstance(payload, dict):
+        raise CliError("Arguments JSON must be an object", code="ARGS_NOT_OBJECT")
+    return payload

cli_anything/indesign/core/runtime.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+from .errors import CliError
+
+
+def package_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _is_server_root(path: Path) -> bool:
+    return (
+        (path / "package.json").exists()
+        and (path / "src" / "index.js").exists()
+        and (path / "src" / "advanced" / "index.js").exists()
+    )
+
+
+def resolve_server_root() -> Path:
+    package_dir = package_root()
+    override = os.environ.get("INDESIGN_CLI_SERVER_ROOT")
+    if override:
+        path = Path(override).resolve()
+        if _is_server_root(path):
+            return path
+        raise CliError("INDESIGN_CLI_SERVER_ROOT does not point to a valid server root", code="SERVER_ROOT_INVALID")
+    for candidate in [*package_dir.parents, package_dir / "server"]:
+        if _is_server_root(candidate):
+            return candidate
+    raise CliError("InDesign CLI server resources were not found", code="SERVER_ROOT_NOT_FOUND")
+
+
+def hidden_handler_bridge_path() -> Path:
+    bridge = package_root() / "node" / "hidden_handler_bridge.mjs"
+    if not bridge.exists():
+        raise CliError("Hidden handler bridge not found", code="HIDDEN_HANDLER_BRIDGE_NOT_FOUND")
+    return bridge
+
+
+def skill_source_path() -> Path:
+    path = package_root() / "skills" / "SKILL.md"
+    if not path.exists():
+        raise CliError("Packaged skill not found", code="SKILL_NOT_FOUND")
+    return path
+
+
+def install_skill(target: Path) -> dict[str, str]:
+    target_root = target.resolve()
+    destination = target_root / ".codex" / "skills" / "indesign-cli" / "SKILL.md"
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(skill_source_path(), destination)
+    return {
+        "target": str(target_root),
+        "installed_path": str(destination),
+        "skill": "indesign-cli",
+    }

cli_anything/indesign/core/scripts.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import locale
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def _read_stdin_text() -> str:
+    buffer = getattr(sys.stdin, "buffer", None)
+    if buffer is None:
+        return sys.stdin.read()
+
+    raw = buffer.read()
+    if isinstance(raw, str):
+        return raw
+
+    encodings = ["utf-8-sig", "utf-8", locale.getpreferredencoding(False)]
+    if sys.platform.startswith("win"):
+        encodings.append("mbcs")
+
+    tried: set[str] = set()
+    for encoding in encodings:
+        if not encoding or encoding in tried:
+            continue
+        tried.add(encoding)
+        try:
+            return raw.decode(encoding)
+        except UnicodeDecodeError:
+            continue
+    return raw.decode("utf-8", errors="replace")
+
+
+def run_script(router: Any, script_path: Path) -> dict[str, Any]:
+    resolved = script_path.resolve()
+    return router.call("template.run_jsx_file", {"filePath": str(resolved)})
+
+
+def run_stdin_script(router: Any, cwd: Path) -> dict[str, Any]:
+    tmp_dir = cwd / ".indesign-cli" / "tmp"
+    tmp_dir.mkdir(parents=True, exist_ok=True)
+    script_path = tmp_dir / "stdin.jsx"
+    script_path.write_text(_read_stdin_text(), encoding="utf-8")
+    return run_script(router, script_path)

cli_anything/indesign/core/session.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+class SessionStore:
+    def __init__(self, cwd: Path) -> None:
+        self.root = cwd / ".indesign-cli"
+        self.path = self.root / "session.json"
+
+    def read(self, compact: bool = True) -> dict[str, Any]:
+        if not self.path.exists():
+            return {"version": 1, "recent_calls": []}
+        payload = json.loads(self.path.read_text(encoding="utf-8"))
+        if compact:
+            payload.pop("verbose_paths", None)
+        return payload
+
+    def write(self, payload: dict[str, Any]) -> None:
+        self.root.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    def record_call(
+        self,
+        *,
+        tool_id: str,
+        domain: str,
+        source: str,
+        ok: bool,
+        duration_ms: int,
+        plugin: str | None = None,
+        artifacts: list[dict[str, Any]] | None = None,
+    ) -> None:
+        payload = self.read(compact=False)
+        calls = payload.setdefault("recent_calls", [])
+        item: dict[str, Any] = {
+            "tool_id": tool_id,
+            "domain": domain,
+            "source": source,
+            "ok": ok,
+            "duration_ms": duration_ms,
+            "time": datetime.now(timezone.utc).isoformat(),
+        }
+        if plugin:
+            item["plugin"] = plugin
+        if artifacts:
+            item["artifacts"] = [
+                {
+                    "kind": artifact.get("kind"),
+                    "path": artifact.get("path"),
+                }
+                for artifact in artifacts
+                if isinstance(artifact, dict) and artifact.get("path")
+            ][:10]
+        calls.insert(
+            0,
+            item,
+        )
+        payload["version"] = 1
+        payload["recent_calls"] = calls[:20]
+        self.write(payload)
+
+    def clear(self) -> None:
+        if self.path.exists():
+            self.path.unlink()