@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

package/skills/cosmic-build/scripts/test/test_mcp_cli.py

@@ -0,0 +1,524 @@
+#!/usr/bin/env python3
+"""Tests for mcp_cli.py — endpoint contract, payload builders, confirm gate, export writeback.
+
+kd_api.post is mocked throughout: these tests pin the *contract* (endpoint
+paths, payload shapes, envelope folding, destructive gating) rather than
+platform behavior. The platform family lives under ai-meta/mcpserver (the
+plain-`mcp` prefix was renamed server-side; requests to the old prefix fail
+gateway routing).
+"""
+from __future__ import annotations
+
+import contextlib
+import io
+import json
+import os
+import sys
+import tempfile
+import unittest
+import urllib.error
+from unittest import mock
+
+_SCRIPTS_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, _SCRIPTS_DIR)
+
+_MCP_SKILL_DIR = os.path.join(os.path.dirname(_SCRIPTS_DIR), "skills", "mcp-server", "scripts")
+if _MCP_SKILL_DIR not in sys.path:
+    sys.path.insert(0, _MCP_SKILL_DIR)
+
+import mcp_cli
+
+
+def _platform_ok(data):
+    return {"status": True, "errorCode": "0", "message": None, "data": data}
+
+
+def _platform_fail(error_code, message):
+    return {"status": False, "errorCode": error_code, "message": message, "data": None}
+
+
+class EndpointContractTest(unittest.TestCase):
+    """Endpoint paths must mirror McpServerApiController (@ApiMapping /ai-meta/mcpserver)."""
+
+    def test_all_nine_endpoints_share_the_ai_meta_mcpserver_prefix(self):
+        for name, path in mcp_cli.ENDPOINTS.items():
+            self.assertTrue(path.startswith("/kapi/v2/devportal/ai-meta/mcpserver/"), f"{name}: {path}")
+        self.assertEqual(
+            set(mcp_cli.ENDPOINTS),
+            {"list", "listByForm", "get", "save", "delete", "importYaml", "resetStatus", "unshelves", "export"},
+        )
+
+    def test_register_status_covers_platform_enum(self):
+        # McpRegisterStatusEnum: SUCCESS/FAILED/UNPUBLISH/UNSHELVES/UNSHELVESED/PENDING_UPDATE
+        self.assertEqual(
+            set(mcp_cli.REGISTER_STATUS),
+            {"SUCCESS", "FAILED", "UNPUBLISH", "UNSHELVES", "UNSHELVESED", "PENDING_UPDATE"},
+        )
+
+
+class HttpMethodRoutingTest(unittest.TestCase):
+    """listByForm/get are served via GET (query params); the platform answers
+    POST on these two paths with HTTP 405 HttpMethod POST is not allowed.
+    The other seven endpoints remain POST + JSON body."""
+
+    def test_get_endpoints_set_is_exactly_listByForm_and_get(self):
+        self.assertEqual(set(mcp_cli.GET_ENDPOINTS), {"listByForm", "get"})
+
+    def test_listByForm_dispatches_to_kd_api_get_with_query_params(self):
+        with mock.patch.object(mcp_cli.kd_api, "get",
+                               return_value=_platform_ok({"formNumber": "x"})) as get_mock, \
+             mock.patch.object(mcp_cli.kd_api, "post") as post_mock:
+            mcp_cli._call("listByForm", {"formNumber": "kdtest_food"}, cfg={})
+        get_mock.assert_called_once()
+        post_mock.assert_not_called()
+        # kd_api.get(base_url, path, config, params=…) — payload rides as query params
+        self.assertEqual(get_mock.call_args.kwargs.get("params"), {"formNumber": "kdtest_food"})
+        self.assertTrue(get_mock.call_args[0][1].endswith("/listByForm"))
+
+    def test_get_command_dispatches_to_kd_api_get_with_query_params(self):
+        with mock.patch.object(mcp_cli.kd_api, "get",
+                               return_value=_platform_ok({"id": 1})) as get_mock, \
+             mock.patch.object(mcp_cli.kd_api, "post") as post_mock:
+            mcp_cli._call("get", {"id": 42}, cfg={})
+        get_mock.assert_called_once()
+        post_mock.assert_not_called()
+        self.assertEqual(get_mock.call_args.kwargs.get("params"), {"id": 42})
+        self.assertTrue(get_mock.call_args[0][1].endswith("/get"))
+
+    def test_write_and_list_endpoints_stay_on_post(self):
+        # A representative sample across the POST family — list (paginated read),
+        # save (write), unshelves (destructive). All must go through kd_api.post.
+        for command in ("list", "save", "unshelves", "importYaml", "resetStatus", "delete", "export"):
+            with self.subTest(command=command), \
+                 mock.patch.object(mcp_cli.kd_api, "post",
+                                   return_value=_platform_ok({})) as post_mock, \
+                 mock.patch.object(mcp_cli.kd_api, "get") as get_mock:
+                mcp_cli._call(command, {"any": "payload"}, cfg={})
+            post_mock.assert_called_once()
+            get_mock.assert_not_called()
+
+
+class ListPayloadTest(unittest.TestCase):
+    def test_defaults_and_filters(self):
+        args = mcp_cli.build_parser().parse_args([
+            "list", "--status", "SUCCESS", "--api-type", "openapi_apilist", "--tool-name", "query",
+        ])
+        payload = mcp_cli.build_list_payload(args)
+        self.assertEqual(payload["pageIndex"], 1)
+        self.assertEqual(payload["pageSize"], 20)
+        self.assertEqual(payload["registerStatus"], "SUCCESS")
+        self.assertEqual(payload["apiType"], "openapi_apilist")
+        self.assertEqual(payload["toolName"], "query")
+        # untouched filters stay absent so the server applies no filter
+        for absent in ("sourceType", "number", "apiNumber"):
+            self.assertNotIn(absent, payload)
+
+    def test_invalid_status_rejected_by_choices(self):
+        with self.assertRaises(SystemExit):
+            mcp_cli.build_parser().parse_args(["list", "--status", "NOT_A_STATUS"])
+
+
+class ListByFormTest(unittest.TestCase):
+    """listByForm: one form number → its APIs plus registered MCP tools."""
+
+    def test_payload_is_flat_form_number(self):
+        args = mcp_cli.build_parser().parse_args(["listByForm", "--form-number", "kdtest_food"])
+        with mock.patch.object(mcp_cli, "_load_config", return_value={}):
+            with mock.patch.object(mcp_cli, "_call",
+                                   return_value=(mcp_cli._ok({"formNumber": "kdtest_food", "apis": [], "items": []}))) as call:
+                result, code = mcp_cli.run_command(args)
+        self.assertEqual(code, 0)
+        self.assertEqual(call.call_args[0][0], "listByForm")
+        self.assertEqual(call.call_args[0][1], {"formNumber": "kdtest_food"})
+
+    def test_form_number_is_required(self):
+        with self.assertRaises(SystemExit):
+            mcp_cli.build_parser().parse_args(["listByForm"])
+
+
+class SavePayloadTest(unittest.TestCase):
+    def test_create_payload_omits_id_and_empty_optionals(self):
+        args = mcp_cli.build_parser().parse_args([
+            "save", "--api-type", "open_rest_api", "--api-id", "42",
+            "--description", "查询在养批次", "--domain", "养殖", "--module", "批次管理",
+        ])
+        payload = mcp_cli.build_save_payload(args)
+        self.assertNotIn("id", payload)
+        self.assertEqual(payload["apiType"], "open_rest_api")
+        self.assertEqual(payload["apiId"], 42)
+        self.assertEqual(payload["description"], "查询在养批次")
+        self.assertEqual(payload["domain"], "养殖")
+        for absent in ("operateType", "toolNameNew", "sourceYaml", "cusParamExtCfg"):
+            self.assertNotIn(absent, payload)
+
+    def test_update_payload_keeps_id_and_maps_every_field(self):
+        args = mcp_cli.build_parser().parse_args([
+            "save", "--id", "7", "--description", "d", "--operate-type", "查询操作",
+            "--module", "m", "--before-condition", "pre", "--after-condition", "post",
+            "--err-recovery", "rec", "--cus-param-ext-cfg", '{"k": "v"}',
+            "--tool-name", "tool_x", "--source-yaml", "yaml-body",
+        ])
+        payload = mcp_cli.build_save_payload(args)
+        self.assertEqual(payload["id"], 7)
+        self.assertEqual(payload["operateType"], "查询操作")
+        self.assertEqual(payload["beforeCondition"], "pre")
+        self.assertEqual(payload["afterCondition"], "post")
+        self.assertEqual(payload["errRecovery"], "rec")
+        self.assertEqual(payload["cusParamExtCfg"], '{"k": "v"}')
+        self.assertEqual(payload["toolNameNew"], "tool_x")
+        self.assertEqual(payload["sourceYaml"], "yaml-body")
+
+    def test_invalid_api_type_rejected(self):
+        with self.assertRaises(SystemExit):
+            mcp_cli.build_parser().parse_args(["save", "--api-type", "not_a_entity", "--api-id", "1"])
+
+    def test_invalid_cus_param_ext_cfg_json_is_cli_argument_error(self):
+        # Client-side JSON validation: a malformed --cus-param-ext-cfg must fail
+        # fast as CLI_ARGUMENT_ERROR (exit 2) instead of a server round-trip.
+        args = mcp_cli.build_parser().parse_args([
+            "save", "--api-type", "openapi_apilist", "--api-id", "1",
+            "--description", "d", "--cus-param-ext-cfg", "{not json",
+        ])
+        with mock.patch.object(mcp_cli, "_call") as call:
+            result, code = mcp_cli.run_command(args)
+        call.assert_not_called()
+        self.assertEqual(result["errorCode"], "CLI_ARGUMENT_ERROR")
+        self.assertIn("cus-param-ext-cfg", result["message"])
+        self.assertEqual(code, 2)
+
+    def test_non_object_cus_param_ext_cfg_is_cli_argument_error(self):
+        # Valid JSON but not an object (array/scalar) must also fail client-side:
+        # the server contract demands an object, so sending it would only yield
+        # a CUS_PARAM_INVALID round-trip (exit 1) instead of exit 2.
+        args = mcp_cli.build_parser().parse_args([
+            "save", "--api-type", "openapi_apilist", "--api-id", "1",
+            "--description", "d", "--cus-param-ext-cfg", "[1, 2]",
+        ])
+        with mock.patch.object(mcp_cli, "_call") as call:
+            result, code = mcp_cli.run_command(args)
+        call.assert_not_called()
+        self.assertEqual(result["errorCode"], "CLI_ARGUMENT_ERROR")
+        self.assertIn("JSON object", result["message"])
+        self.assertEqual(code, 2)
+
+    def test_argparse_error_emits_json_line(self):
+        # argparse-level errors (bad enum, missing flag, unknown subcommand) must
+        # also print a single JSON line — the CLI has no human mode.
+        with contextlib.redirect_stdout(io.StringIO()) as out:
+            with self.assertRaises(SystemExit) as ctx:
+                mcp_cli.build_parser().parse_args(["list", "--status", "BOGUS"])
+        result = json.loads(out.getvalue())
+        self.assertEqual(result["errorCode"], "CLI_ARGUMENT_ERROR")
+        self.assertEqual(ctx.exception.code, 2)
+
+
+class ConfirmGateTest(unittest.TestCase):
+    """delete/resetStatus/unshelves must refuse to run without --confirm."""
+
+    def test_destructive_commands_require_confirm(self):
+        for command in ("delete", "resetStatus", "unshelves"):
+            args = mcp_cli.build_parser().parse_args([command, "--ids", "1,2"])
+            with mock.patch.object(mcp_cli, "_call") as call:
+                result, code = mcp_cli.run_command(args)
+            call.assert_not_called()
+            self.assertFalse(result["status"])
+            self.assertEqual(result["errorCode"], "CONFIRM_REQUIRED")
+            self.assertEqual(code, 2)
+
+    def test_confirmed_delete_calls_platform_with_ids(self):
+        args = mcp_cli.build_parser().parse_args(["delete", "--ids", "1,2,3", "--confirm"])
+        with mock.patch.object(mcp_cli, "_call", return_value=(mcp_cli._ok({"successCount": 3}))) as call:
+            result, code = mcp_cli.run_command(args)
+        call.assert_called_once()
+        # _call(command, payload, cfg): payload carries the parsed id list
+        self.assertEqual(call.call_args[0][1]["ids"], [1, 2, 3])
+        self.assertEqual(code, 0)
+        self.assertTrue(result["status"])
+
+
+class IdParsingTest(unittest.TestCase):
+    def test_comma_and_space_both_accepted(self):
+        self.assertEqual(mcp_cli._parse_ids("1, 2 3"), [1, 2, 3])
+
+    def test_non_numeric_rejected(self):
+        with self.assertRaises(ValueError):
+            mcp_cli._parse_ids("1,abc")
+
+    def test_empty_rejected(self):
+        with self.assertRaises(ValueError):
+            mcp_cli._parse_ids(" , ")
+
+
+class CallFoldingTest(unittest.TestCase):
+    """CustomApiResult → CLI envelope folding, both directions."""
+
+    def test_platform_success_folds_to_ok_with_data(self):
+        with mock.patch.object(mcp_cli.kd_api, "post", return_value=_platform_ok({"total": 5})):
+            result = mcp_cli._call("list", {}, cfg={})
+        self.assertTrue(result["status"])
+        self.assertEqual(result["data"], {"total": 5})
+
+    def test_platform_failure_keeps_error_code_and_message(self):
+        platform = _platform_fail("STATUS_LOCKED", "该MCP服务当前为已发布状态，请先下架后再编辑。")
+        with mock.patch.object(mcp_cli.kd_api, "post", return_value=platform):
+            result = mcp_cli._call("save", {}, cfg={})
+        self.assertFalse(result["status"])
+        self.assertEqual(result["errorCode"], "STATUS_LOCKED")
+        self.assertIn("下架", result["message"])
+
+    def test_platform_failure_without_code_falls_back(self):
+        platform = {"status": False, "errorCode": None, "message": "boom"}
+        with mock.patch.object(mcp_cli.kd_api, "get", return_value=platform):
+            result = mcp_cli._call("get", {}, cfg={})
+        self.assertEqual(result["errorCode"], "PLATFORM_ERROR")
+
+    def test_transport_exception_folds_to_platform_error(self):
+        # Misrouted or undeployed endpoints answer with a gateway 400/NPE at
+        # the HTTP layer; the CLI must emit a clean JSON envelope instead of
+        # leaking a traceback into the machine output.
+        with mock.patch.object(mcp_cli.kd_api, "post", side_effect=urllib.error.HTTPError(
+            None, 400, "Bad Request", None, None)):
+            result = mcp_cli._call("list", {}, cfg={})
+        self.assertFalse(result["status"])
+        self.assertEqual(result["errorCode"], "PLATFORM_ERROR")
+        self.assertIn("list call failed", result["message"])
+
+    def test_load_config_flattens_server_section(self):
+        # load_effective_skill_config returns {server: {baseUrl, appId, ...}};
+        # kd_api reads flat top-level keys. _load_config must bridge the shape.
+        nested = {"server": {"baseUrl": "https://x/ierp", "appId": "a", "appSecret": "s"},
+                  "pdm": {"outputDir": "datamodel"}}
+        with mock.patch.object(mcp_cli, "load_effective_skill_config", return_value=nested):
+            flat = mcp_cli._load_config()
+        self.assertEqual(flat["baseUrl"], "https://x/ierp")
+        self.assertEqual(flat["appId"], "a")
+        self.assertEqual(flat["outputDir"], "datamodel")
+
+
+class MessageSanitizationTest(unittest.TestCase):
+    """Platform failure messages carry TraceId/WebInstance/Java stacks that can
+    run kilobytes long (e.g. bos.orm.read.dataNotExist on a deleted record);
+    the single-JSON machine output must stay compact while TraceId survives."""
+
+    def test_stack_trace_is_stripped_trace_id_survives(self):
+        platform = _platform_fail(
+            "bos.orm.read.dataNotExist",
+            "MCP服务 数据在系统中不存在，可能已经被删除。,TraceId：3ecc3add3b8aaee   \n"
+            "WebInstance：feature-vb-test-web-082415920   \nTime:2026/09/23 10:42:13   \n"
+            "====Stack====   \nkd.bos.exception.KDException: MCP服务数据在系统中不存在\n"
+            "\tat kd.bos.orm.dataentity.DataManagerImplement.read(DataManagerImplement.java:1875)",
+        )
+        with mock.patch.object(mcp_cli.kd_api, "get", return_value=platform):
+            result = mcp_cli._call("get", {"id": 1}, cfg={})
+        self.assertFalse(result["status"])
+        self.assertEqual(result["errorCode"], "bos.orm.read.dataNotExist")
+        self.assertIn("TraceId", result["message"])
+        self.assertNotIn("====Stack====", result["message"])
+        self.assertNotIn("KDException", result["message"])
+
+    def test_overlong_message_without_stack_is_truncated(self):
+        platform = _platform_fail("STATUS_LOCKED", "x" * 3000)
+        with mock.patch.object(mcp_cli.kd_api, "post", return_value=platform):
+            result = mcp_cli._call("save", {}, cfg={})
+        self.assertTrue(result["message"].endswith("...(truncated)"))
+        self.assertLessEqual(len(result["message"]), mcp_cli._MESSAGE_LIMIT + len("...(truncated)"))
+
+    def test_short_message_without_stack_passes_through(self):
+        message = "该MCP服务当前为已发布状态，请先下架后再编辑。"
+        platform = _platform_fail("STATUS_LOCKED", message)
+        with mock.patch.object(mcp_cli.kd_api, "post", return_value=platform):
+            result = mcp_cli._call("save", {}, cfg={})
+        self.assertEqual(result["message"], message)
+
+
+class ReleaseDecouplingTest(unittest.TestCase):
+    """灵基/苍穹发版解耦：接口族缺失时给出 MCP_API_NOT_DEPLOYED 而非笼统 PLATFORM_ERROR。
+
+    Lingee and Cosmic release independently; an updated skill tree may run
+    against an older platform without the ai-meta/mcpserver family. Both
+    not-deployed signatures must map to a dedicated, actionable error code.
+    """
+
+    def _http_error(self, code, body_text):
+        return urllib.error.HTTPError(
+            None, code, "Error", None,
+            io.BytesIO(body_text.encode("utf-8")) if body_text else None)
+
+    def test_gateway_npe_without_trace_id_is_not_deployed(self):
+        # API entry registered in the platform list, backend controller missing:
+        # gateway answers HTTP 400 + NPE with TraceId：null (never reaches a business instance).
+        body = ('{"data":null,"errorCode":"500",'
+                '"message":"java.lang.NullPointerException,TraceId：null","status":false}')
+        with mock.patch.object(mcp_cli.kd_api, "post", side_effect=self._http_error(400, body)):
+            result = mcp_cli._call("list", {}, cfg={})
+        self.assertFalse(result["status"])
+        self.assertEqual(result["errorCode"], "MCP_API_NOT_DEPLOYED")
+        self.assertIn("not deployed", result["message"])
+
+    def test_http_404_is_not_deployed(self):
+        body = '{"data":null,"errorCode":"404","message":"Cannot found OpenAPI","status":false}'
+        with mock.patch.object(mcp_cli.kd_api, "get", side_effect=self._http_error(404, body)):
+            result = mcp_cli._call("get", {}, cfg={})
+        self.assertEqual(result["errorCode"], "MCP_API_NOT_DEPLOYED")
+
+    def test_body_level_404_envelope_is_not_deployed(self):
+        # The platform often answers HTTP 200 with a body-level errorCode=404
+        # ("Cannot found OpenAPI"); kd_auth surfaces it as an exception
+        # mentioning 404 — both shapes mean "no API entry on this environment".
+        platform = _platform_fail("404", "Cannot found OpenAPI(or disabled)")
+        with mock.patch.object(mcp_cli.kd_api, "post", return_value=platform):
+            result = mcp_cli._call("list", {}, cfg={})
+        self.assertEqual(result["errorCode"], "MCP_API_NOT_DEPLOYED")
+
+    def test_business_npe_with_real_trace_id_stays_platform_error(self):
+        # An NPE WITH a TraceId comes from a live business instance (a genuine
+        # server bug), not a missing deployment — must not be misclassified.
+        body = ('{"data":null,"errorCode":"500",'
+                '"message":"java.lang.NullPointerException,TraceId：a41f8c81fe2eec37","status":false}')
+        with mock.patch.object(mcp_cli.kd_api, "post", side_effect=self._http_error(400, body)):
+            result = mcp_cli._call("save", {}, cfg={})
+        self.assertEqual(result["errorCode"], "PLATFORM_ERROR")
+
+    def test_trace_id_hex_containing_404_substring_stays_platform_error(self):
+        # A REAL TraceId whose hex happens to contain "404" (e.g. a41f404c81fe2eec37)
+        # must NOT trip the not-deployed classifier: bare substring matching would
+        # misreport a genuine server-side defect as a deployment gap AND drop the
+        # TraceId the user needs for the defect report. Word-boundary matching keeps
+        # the original detail (TraceId included) in the PLATFORM_ERROR message.
+        body = ('{"data":null,"errorCode":"500",'
+                '"message":"java.lang.NullPointerException,TraceId：a41f404c81fe2eec37","status":false}')
+        with mock.patch.object(mcp_cli.kd_api, "post", side_effect=self._http_error(400, body)):
+            result = mcp_cli._call("list", {}, cfg={})
+        self.assertEqual(result["errorCode"], "PLATFORM_ERROR")
+        self.assertIn("a41f404c81fe2eec37", result["message"])
+
+    def test_standalone_404_in_token_expired_message_is_not_deployed(self):
+        # Regression guard for the word-boundary switch: "404" as a standalone
+        # token (not embedded in a longer hex/number) still classifies as
+        # not-deployed, exactly like the old substring behavior.
+        with mock.patch.object(mcp_cli.kd_api, "get",
+                               side_effect=RuntimeError("Business code token expired: 404")):
+            result = mcp_cli._call("listByForm", {}, cfg={})
+        self.assertEqual(result["errorCode"], "MCP_API_NOT_DEPLOYED")
+
+    def test_not_deployed_error_fails_with_exit_code_one(self):
+        # MCP_API_NOT_DEPLOYED flows through run_command as a platform failure (exit 1)
+        args = mcp_cli.build_parser().parse_args(["listByForm", "--form-number", "kdtest_food"])
+        with mock.patch.object(mcp_cli, "_load_config", return_value={}):
+            with mock.patch.object(mcp_cli, "_call",
+                                   return_value=(mcp_cli._fail("MCP_API_NOT_DEPLOYED", "not deployed"))):
+                result, code = mcp_cli.run_command(args)
+        self.assertEqual(code, 1)
+        self.assertEqual(result["errorCode"], "MCP_API_NOT_DEPLOYED")
+
+
+class ImportYamlTest(unittest.TestCase):
+    def test_payload_reads_file_and_defaults_mode_override(self):
+        with tempfile.NamedTemporaryFile("w", suffix=".yaml", delete=False, encoding="utf-8") as handle:
+            handle.write("paths:\n  /v2/open/x/query:\n")
+            path = handle.name
+        try:
+            args = mcp_cli.build_parser().parse_args(["importYaml", "--file", path])
+            payload = mcp_cli.build_import_payload(args)
+            self.assertIn("paths:", payload["yamlContent"])
+            self.assertEqual(payload["fileName"], os.path.basename(path))
+            self.assertEqual(payload["mode"], "override")
+            self.assertIs(payload["saveYaml"], False)
+        finally:
+            os.unlink(path)
+
+    def test_missing_file_is_cli_argument_error(self):
+        args = mcp_cli.build_parser().parse_args(["importYaml", "--file", "/nonexistent/x.yaml"])
+        result, code = mcp_cli.run_command(args)
+        self.assertEqual(result["errorCode"], "CLI_ARGUMENT_ERROR")
+        self.assertEqual(code, 2)
+
+
+class ExportTest(unittest.TestCase):
+    def test_export_writes_content_and_strips_it_from_stdout_json(self):
+        platform_data = {
+            "success": True, "format": "yaml", "fileName": "mcp_1.yaml",
+            "content": "paths: {}\n", "count": 1,
+        }
+        args = mcp_cli.build_parser().parse_args(["export", "--ids", "1", "--format", "yaml"])
+        with mock.patch.object(mcp_cli, "_call", return_value=(mcp_cli._ok(platform_data))):
+            with tempfile.TemporaryDirectory() as tmp:
+                args.output = os.path.join(tmp, "out.yaml")
+                result, code = mcp_cli.run_command(args)
+                self.assertEqual(code, 0)
+                self.assertEqual(result["data"]["count"], 1)
+                self.assertEqual(result["data"]["savedTo"], args.output)
+                self.assertNotIn("content", result["data"])
+                with open(args.output, encoding="utf-8") as handle:
+                    self.assertEqual(handle.read(), "paths: {}\n")
+
+    def test_export_rejects_unknown_format(self):
+        with self.assertRaises(SystemExit):
+            mcp_cli.build_parser().parse_args(["export", "--ids", "1", "--format", "xlsx"])
+
+
+class MainOutputTest(unittest.TestCase):
+    def test_main_prints_single_json_line_and_exit_code(self):
+        with mock.patch.object(mcp_cli, "_load_config", return_value={}):
+            with mock.patch.object(mcp_cli.kd_api, "post", return_value=_platform_ok({"items": []})):
+                with mock.patch("sys.stdout", new_callable=lambda: _StdoutCapture()) as fake:
+                    code = mcp_cli.main(["list", "--page-size", "5"])
+        self.assertEqual(code, 0)
+        self.assertEqual(len(fake.lines), 1)
+        parsed = json.loads(fake.lines[0])
+        self.assertTrue(parsed["status"])
+        self.assertEqual(parsed["data"], {"items": []})
+
+    def test_main_argument_error_exit_code_two(self):
+        with mock.patch("sys.stdout", new_callable=lambda: _StdoutCapture()) as fake:
+            code = mcp_cli.main(["importYaml", "--file", "/nonexistent/y.yaml"])
+        self.assertEqual(code, 2)
+        parsed = json.loads(fake.lines[0])
+        self.assertEqual(parsed["errorCode"], "CLI_ARGUMENT_ERROR")
+
+    def test_main_folds_unexpected_exception_to_cli_execution_error(self):
+        # kd_env_loader failures (e.g. no default environment configured) surface
+        # as RuntimeError from _load_config, outside run_command's own catches.
+        # The single-JSON-line contract must still hold: one JSON line, exit 1,
+        # CLI_EXECUTION_ERROR envelope — never a bare traceback on stdout.
+        with mock.patch.object(mcp_cli, "_load_config", side_effect=RuntimeError("no default kd env")):
+            with mock.patch("sys.stdout", new_callable=lambda: _StdoutCapture()) as fake:
+                code = mcp_cli.main(["list"])
+        self.assertEqual(code, 1)
+        self.assertEqual(len(fake.lines), 1)
+        parsed = json.loads(fake.lines[0])
+        self.assertFalse(parsed["status"])
+        self.assertEqual(parsed["errorCode"], "CLI_EXECUTION_ERROR")
+        self.assertIn("no default kd env", parsed["message"])
+
+    def test_unreadable_import_file_is_cli_argument_error(self):
+        # PermissionError (an OSError) from _read_file must fold into
+        # CLI_ARGUMENT_ERROR exit 2 — the --file argument points to a file
+        # the process cannot read; no traceback may escape either.
+        args = mcp_cli.build_parser().parse_args(["importYaml", "--file", "/etc/shadow"])
+        with mock.patch.object(mcp_cli, "_read_file",
+                               side_effect=PermissionError(13, "Permission denied", "/etc/shadow")):
+            result, code = mcp_cli.run_command(args)
+        self.assertEqual(result["errorCode"], "CLI_ARGUMENT_ERROR")
+        self.assertIn("Permission denied", result["message"])
+        self.assertEqual(code, 2)
+
+
+class _StdoutCapture:
+    """Minimal stdout double that records whole printed lines."""
+
+    def __init__(self):
+        self.lines = []
+
+    def write(self, text):
+        if text.strip():
+            self.lines.append(text.strip())
+        return len(text)
+
+    def flush(self):
+        pass
+
+
+if __name__ == "__main__":
+    unittest.main()