indesign-cli 0.2.0__py3-none-any.whl

cli_anything/indesign/indesign_cli.py

@@ -0,0 +1,320 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+from .core.artifacts import parse_timestamp, verify_artifact
+from .core.catalog import Catalog
+from .core.catalog import plugin_tool_entries
+from .core.envelope import failure, now_ms, success
+from .core.errors import CliError
+from .core.health import health
+from .core.mcp_backend import McpBackend
+from .core.node_setup import setup_node_dependencies
+from .core.plugins.backend import PluginBackend
+from .core.plugins.discovery import discover_plugins
+from .core.plugins.install import install_plugin, list_plugins, remove_plugin
+from .core.plugins.validate import doctor_plugin, validate_plugin_path
+from .core.router import Router, load_args
+from .core.runtime import install_skill, resolve_server_root
+from .core.scripts import run_script, run_stdin_script
+from .core.session import SessionStore
+
+
+SERVER_ROOT = resolve_server_root()
+REPO_ROOT = SERVER_ROOT
+
+
+def emit(payload: dict[str, Any]) -> int:
+    print(json.dumps(payload, ensure_ascii=True, indent=2))
+    return int(payload.get("exit_code", 0))
+
+
+def version_payload() -> dict[str, Any]:
+    return success(
+        command="version",
+        data={
+            "name": "indesign-cli",
+            "version": __version__,
+            "aliases": ["cli-anything-indesign"],
+        },
+        duration_ms=0,
+    )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="indesign-cli")
+    parser.add_argument("--version", action="store_true")
+    parser.add_argument("--json", action="store_true")
+    parser.add_argument("--pretty", action="store_true")
+    subparsers = parser.add_subparsers(dest="group")
+
+    tool_parser = subparsers.add_parser("tool")
+    tool_sub = tool_parser.add_subparsers(dest="tool_command")
+    tool_sub.add_parser("domains")
+    list_parser = tool_sub.add_parser("list")
+    list_parser.add_argument("--domain")
+    list_parser.add_argument("--source")
+    list_parser.add_argument("--callable-only", action="store_true")
+    search_parser = tool_sub.add_parser("search")
+    search_parser.add_argument("--domain")
+    search_parser.add_argument("--source")
+    search_parser.add_argument("--query", required=True)
+    schema_parser = tool_sub.add_parser("schema")
+    schema_parser.add_argument("tool_id")
+    call_parser = tool_sub.add_parser("call")
+    call_parser.add_argument("tool_id")
+    call_parser.add_argument("--args", required=True)
+    call_parser.add_argument("--timeout", type=int, help="MCP/script backend timeout in seconds")
+
+    script_parser = subparsers.add_parser("script")
+    script_sub = script_parser.add_subparsers(dest="script_command")
+    run_parser = script_sub.add_parser("run")
+    run_parser.add_argument("file", nargs="?")
+    run_parser.add_argument("--stdin", action="store_true")
+    run_parser.add_argument("--timeout", type=int, default=300, help="Script backend timeout in seconds")
+
+    export_parser = subparsers.add_parser("export")
+    export_sub = export_parser.add_subparsers(dest="export_command")
+    verify_parser = export_sub.add_parser("verify")
+    verify_parser.add_argument("path")
+    verify_parser.add_argument("--created-after")
+
+    session_parser = subparsers.add_parser("session")
+    session_sub = session_parser.add_subparsers(dest="session_command")
+    show_parser = session_sub.add_parser("show")
+    show_parser.add_argument("--verbose", action="store_true")
+    session_sub.add_parser("clear")
+
+    server_parser = subparsers.add_parser("server")
+    server_sub = server_parser.add_subparsers(dest="server_command")
+    health_parser = server_sub.add_parser("health")
+    health_parser.add_argument("--deep", action="store_true")
+    server_sub.add_parser("setup")
+
+    skill_parser = subparsers.add_parser("skill")
+    skill_sub = skill_parser.add_subparsers(dest="skill_command")
+    install_parser = skill_sub.add_parser("install")
+    install_parser.add_argument("--target", default=".")
+
+    plugin_parser = subparsers.add_parser("plugin")
+    plugin_sub = plugin_parser.add_subparsers(dest="plugin_command")
+    plugin_sub.add_parser("list")
+    plugin_install = plugin_sub.add_parser("install")
+    plugin_install.add_argument("path")
+    plugin_remove = plugin_sub.add_parser("remove")
+    plugin_remove.add_argument("id")
+    plugin_validate = plugin_sub.add_parser("validate")
+    plugin_validate.add_argument("path")
+    plugin_doctor = plugin_sub.add_parser("doctor")
+    plugin_doctor.add_argument("id")
+    plugin_doctor.add_argument("--deep", action="store_true")
+    return parser
+
+
+def build_catalog_with_backends() -> tuple[Catalog, list[str]]:
+    base = Catalog(repo_root=REPO_ROOT)
+    warnings: list[str] = []
+    advanced_tools: list[dict[str, Any]] = []
+    classic_tools: list[dict[str, Any]] = []
+    plugin_tools: list[dict[str, Any]] = []
+    plugin_domain_summaries: dict[str, str] = {}
+    plugin_records = {}
+    for source, entry, sink in (
+        ("advanced", "src/advanced/index.js", advanced_tools),
+        ("classic", "src/index.js", classic_tools),
+    ):
+        try:
+            sink.extend(McpBackend(repo_root=REPO_ROOT, entry=entry).list_tools())
+        except CliError as exc:
+            warnings.append(f"{source} backend unavailable: {exc.code}")
+    try:
+        discovered, plugin_warnings = discover_plugins(Path.cwd(), host_version=__version__)
+        warnings.extend(plugin_warnings)
+    except CliError as exc:
+        discovered = []
+        warnings.append(f"plugin discovery unavailable: {exc.code}")
+    for record in discovered:
+        try:
+            backend = PluginBackend(record)
+            backend.handshake({"name": "indesign-cli", "version": __version__, "protocol": record.manifest["protocol"]})
+            plugin_tools.extend(plugin_tool_entries(record, backend.list_tools()))
+            plugin_domain_summaries[record.domain] = str(record.manifest.get("description") or f"{record.id} plugin tools")
+            plugin_records[record.id] = record
+        except CliError as exc:
+            warnings.append(f"plugin {record.id} unavailable: {exc.code}")
+    return (
+        base.with_exposed_tools(
+            advanced_tools=advanced_tools,
+            classic_tools=classic_tools,
+            plugin_tools=plugin_tools,
+            plugin_domain_summaries=plugin_domain_summaries,
+            plugin_records=plugin_records,
+        ),
+        warnings,
+    )
+
+
+def emit_check(command: str, data: dict[str, Any], *, tool_id: str | None = None) -> int:
+    payload = success(command=command, data=data, duration_ms=0, tool_id=tool_id)
+    if data.get("ok") is False:
+        payload["ok"] = False
+        payload["exit_code"] = 1
+        payload["tool_success"] = False
+    return emit(payload)
+
+
+def run(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.version:
+        return emit(version_payload())
+    if args.group == "tool":
+        catalog, warnings = build_catalog_with_backends()
+        if args.tool_command == "domains" or args.tool_command is None:
+            return emit(success(command="tool domains", data=catalog.domains(), duration_ms=0, warnings=warnings))
+        if args.tool_command == "list":
+            if not args.domain and not args.source:
+                return emit(success(command="tool list", data=catalog.domains(), duration_ms=0, warnings=warnings))
+            data = catalog.list_tools(
+                domain=args.domain,
+                source=args.source,
+                callable_only=args.callable_only,
+            )
+            return emit(success(command="tool list", data=data, duration_ms=0, warnings=warnings))
+        if args.tool_command == "search":
+            data = catalog.list_tools(domain=args.domain, source=args.source, query=args.query)
+            return emit(success(command="tool search", data=data, duration_ms=0, warnings=warnings))
+        router = Router(catalog=catalog, repo_root=REPO_ROOT, backend_timeout_seconds=getattr(args, "timeout", None))
+        if args.tool_command == "schema":
+            data = router.schema(args.tool_id)
+            return emit(success(command="tool schema", data=data, duration_ms=0, tool_id=args.tool_id, warnings=warnings))
+        if args.tool_command == "call":
+            call_args = load_args(args.args)
+            tool = router._find(args.tool_id)
+            store = SessionStore(Path.cwd())
+            try:
+                data = router.call(args.tool_id, call_args)
+            except CliError:
+                store.record_call(
+                    tool_id=args.tool_id,
+                    domain=tool["domain"],
+                    source=tool["source"],
+                    ok=False,
+                    duration_ms=0,
+                    plugin=tool.get("plugin"),
+                )
+                raise
+            store.record_call(
+                tool_id=args.tool_id,
+                domain=tool["domain"],
+                source=tool["source"],
+                ok=True,
+                duration_ms=0,
+                plugin=tool.get("plugin"),
+                artifacts=data.get("artifacts") if isinstance(data, dict) else None,
+            )
+            return emit(
+                success(
+                    command="tool call",
+                    data=data,
+                    duration_ms=0,
+                    tool_id=args.tool_id,
+                    domain=tool["domain"],
+                    source=tool["source"],
+                    warnings=warnings,
+                )
+            )
+    if args.group == "plugin":
+        if args.plugin_command == "list" or args.plugin_command is None:
+            data = list_plugins(cwd=Path.cwd(), host_version=__version__)
+            return emit(success(command="plugin list", data=data, duration_ms=0, tool_id="plugin.list", domain="plugin", source="cli", warnings=data.get("warnings", [])))
+        if args.plugin_command == "install":
+            data = install_plugin(args.path, cwd=Path.cwd(), host_version=__version__)
+            return emit(success(command="plugin install", data=data, duration_ms=0, tool_id="plugin.install", domain="plugin", source="cli"))
+        if args.plugin_command == "remove":
+            data = remove_plugin(args.id, cwd=Path.cwd())
+            return emit(success(command="plugin remove", data=data, duration_ms=0, tool_id="plugin.remove", domain="plugin", source="cli"))
+        if args.plugin_command == "validate":
+            data = validate_plugin_path(args.path, host_version=__version__)
+            return emit_check("plugin validate", data, tool_id="plugin.validate")
+        if args.plugin_command == "doctor":
+            data = doctor_plugin(args.id, cwd=Path.cwd(), host_version=__version__, deep=bool(args.deep))
+            return emit_check("plugin doctor", data, tool_id="plugin.doctor")
+    if args.group == "script" and args.script_command == "run":
+        catalog, warnings = build_catalog_with_backends()
+        router = Router(catalog=catalog, repo_root=REPO_ROOT, backend_timeout_seconds=args.timeout)
+        store = SessionStore(Path.cwd())
+        try:
+            if args.stdin:
+                data = run_stdin_script(router, Path.cwd())
+            elif args.file:
+                data = run_script(router, Path(args.file))
+            else:
+                raise CliError("script run requires a file path or --stdin", code="SCRIPT_INPUT_REQUIRED")
+        except Exception:
+            store.record_call(tool_id="script.run", domain="script", source="script", ok=False, duration_ms=0)
+            raise
+        store.record_call(tool_id="script.run", domain="script", source="script", ok=True, duration_ms=0)
+        return emit(success(command="script run", data=data, duration_ms=0, tool_id="script.run", domain="script", source="script", warnings=warnings))
+    if args.group == "export" and args.export_command == "verify":
+        try:
+            created_after = parse_timestamp(args.created_after) if args.created_after else None
+        except ValueError as exc:
+            raise CliError("created-after must be an ISO timestamp", code="BAD_TIMESTAMP") from exc
+        data = verify_artifact(Path(args.path), created_after=created_after, cwd=Path.cwd())
+        SessionStore(Path.cwd()).record_call(tool_id="export.verify", domain="export", source="cli", ok=True, duration_ms=0)
+        return emit(success(command="export verify", data=data, duration_ms=0, tool_id="export.verify", domain="export", source="cli"))
+    if args.group == "session":
+        store = SessionStore(Path.cwd())
+        if args.session_command == "show" or args.session_command is None:
+            data = store.read(compact=not getattr(args, "verbose", False))
+            return emit(success(command="session show", data=data, duration_ms=0, tool_id="session.show"))
+        if args.session_command == "clear":
+            store.clear()
+            return emit(success(command="session clear", data={"cleared": True}, duration_ms=0, tool_id="session.clear"))
+    if args.group == "server" and (args.server_command == "health" or args.server_command is None):
+        data = health(REPO_ROOT, deep=getattr(args, "deep", False))
+        return emit(success(command="server health", data=data, duration_ms=0, tool_id="server.health"))
+    if args.group == "server" and args.server_command == "setup":
+        data = setup_node_dependencies(REPO_ROOT)
+        return emit(success(command="server setup", data=data, duration_ms=0, tool_id="server.setup", domain="server", source="cli"))
+    if args.group == "skill" and args.skill_command == "install":
+        data = install_skill(Path(args.target))
+        return emit(success(command="skill install", data=data, duration_ms=0, tool_id="skill.install", domain="skill", source="cli"))
+    raise CliError(
+        "Command is required",
+        code="COMMAND_REQUIRED",
+        details={"groups": ["tool", "script", "export", "session", "server", "skill", "plugin"]},
+        hint="先用 tool domains 查看工具域，或用 tool search --query <关键词> 查找工具。",
+    )
+
+
+def safe_command(argv: list[str] | None) -> str:
+    parts = list(argv if argv is not None else sys.argv[1:])
+    while parts and parts[0] in {"--json", "--pretty"}:
+        parts.pop(0)
+    if not parts:
+        return "cli"
+    if parts[0] == "tool" and len(parts) > 1:
+        return f"tool {parts[1]}"
+    if parts[0] in {"script", "export", "session", "skill", "plugin"} and len(parts) > 1:
+        return f"{parts[0]} {parts[1]}"
+    return parts[0]
+
+
+def main(argv: list[str] | None = None) -> int:
+    start = now_ms()
+    try:
+        return run(argv)
+    except CliError as exc:
+        duration_ms = now_ms() - start
+        return emit(failure(command=safe_command(argv), error=exc, duration_ms=duration_ms))
+    except Exception as exc:
+        duration_ms = now_ms() - start
+        error = CliError("Unexpected CLI error", code="UNEXPECTED_ERROR", details={"type": exc.__class__.__name__})
+        return emit(failure(command=safe_command(argv), error=error, duration_ms=duration_ms))

cli_anything/indesign/node/hidden_handler_bridge.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { env, stdin, stdout } from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function resolveServerRoot() {
+  const candidates = [
+    env.INDESIGN_CLI_SERVER_ROOT,
+    path.resolve(__dirname, '../../../../'),
+    path.resolve(__dirname, '../server'),
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    if (
+      fs.existsSync(path.join(candidate, 'src', 'handlers', 'bookHandlers.js')) &&
+      fs.existsSync(path.join(candidate, 'src', 'handlers', 'presentationHandlers.js'))
+    ) {
+      return candidate;
+    }
+  }
+
+  throw new Error('Unable to resolve InDesign CLI server root');
+}
+
+const serverRoot = resolveServerRoot();
+const { BookHandlers } = await import(pathToFileURL(path.join(serverRoot, 'src', 'handlers', 'bookHandlers.js')).href);
+const { PresentationHandlers } = await import(
+  pathToFileURL(path.join(serverRoot, 'src', 'handlers', 'presentationHandlers.js')).href
+);
+
+const HANDLERS = {
+  book: BookHandlers,
+  presentation: PresentationHandlers,
+};
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    stdin.setEncoding('utf8');
+    stdin.on('data', chunk => {
+      data += chunk;
+    });
+    stdin.on('end', () => resolve(data));
+    stdin.on('error', reject);
+  });
+}
+
+function snakeToCamel(value) {
+  return String(value || '').replace(/_([a-z0-9])/g, (_match, letter) => letter.toUpperCase());
+}
+
+function camelToSnake(value) {
+  return String(value || '')
+    .replace(/(.)([A-Z][a-z]+)/g, '$1_$2')
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .toLowerCase();
+}
+
+function resolveMethodName(handlerClass, name) {
+  const normalized = String(name || '');
+  for (const candidate of Object.getOwnPropertyNames(handlerClass)) {
+    if (typeof handlerClass[candidate] === 'function' && camelToSnake(candidate) === normalized) {
+      return candidate;
+    }
+  }
+  return snakeToCamel(normalized);
+}
+
+function failure(code, message) {
+  return {
+    ok: false,
+    error: { code, message },
+  };
+}
+
+async function main() {
+  const input = await readStdin();
+  const request = JSON.parse(input || '{}');
+  const domain = request.domain;
+  const name = request.name;
+  const args = request.args || {};
+
+  const handlerClass = HANDLERS[domain];
+  if (!handlerClass) {
+    return failure('HIDDEN_HANDLER_DOMAIN_NOT_FOUND', `Unknown hidden handler domain: ${domain}`);
+  }
+
+  const methodName = resolveMethodName(handlerClass, name);
+  const method = handlerClass[methodName];
+  if (typeof method !== 'function') {
+    return failure('HIDDEN_HANDLER_METHOD_NOT_FOUND', `Unknown hidden handler method: ${domain}.${name}`);
+  }
+
+  if (request.resolveOnly) {
+    return { ok: true, methodName };
+  }
+
+  const result = await method.call(handlerClass, args);
+  return { ok: true, result };
+}
+
+main()
+  .then(payload => {
+    stdout.write(JSON.stringify(payload));
+  })
+  .catch(error => {
+    stdout.write(JSON.stringify(failure('HIDDEN_HANDLER_EXCEPTION', error?.message || String(error))));
+  });

cli_anything/indesign/server/package-lock.json

@@ -0,0 +1,168 @@
+{
+  "name": "indesign-cli",
+  "version": "0.2.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "indesign-cli",
+      "version": "0.2.0",
+      "license": "MIT",
+      "dependencies": {
+        "@modelcontextprotocol/sdk": "^0.5.0",
+        "winax": "^3.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-0.5.0.tgz",
+      "integrity": "sha512-RXgulUX6ewvxjAG0kOpLMEdXXWkzWgaoCGaA2CwNW7cQCIphjpJhjpHSiaPdVCnisjRF/0Cm9KWHUuIoeiAblQ==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz",
+      "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.6.3",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/winax": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/winax/-/winax-3.6.2.tgz",
+      "integrity": "sha512-KvNO9lBBW//F4k4kE3QzKWHyGchMswrwSC2TD/rS4BYLaypECPCRXQIyjmQHVteK7cBEqqdF288brwnig/67Ow==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "nodewscript": "NodeWScript.js"
+      },
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

cli_anything/indesign/server/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "indesign-cli",
+  "version": "0.2.0",
+  "description": "Agent-native CLI and MCP runtime for Adobe InDesign automation",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node --inspect src/index.js",
+    "build": "echo 'No build step required for Node.js'",
+    "test": "echo 'No tests specified'"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "indesign",
+    "adobe",
+    "automation",
+    "publishing",
+    "desktop-publishing",
+    "claude",
+    "ai",
+    "llm",
+    "design-automation",
+    "document-creation",
+    "layout-automation"
+  ],
+  "author": "Sa",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "winax": "^3.6.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhanglongxiao111/indesign-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zhanglongxiao111/indesign-cli/issues"
+  },
+  "homepage": "https://github.com/zhanglongxiao111/indesign-cli#readme"
+}