hap-cli 0.5.0__py3-none-any.whl

hap_cli/tests/test_core.py

@@ -0,0 +1,1824 @@
+"""Unit tests for hap-cli harness core modules."""
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from hap_cli.core.session import (
+    Session,
+    SessionError,
+    APIError,
+    load_config,
+    save_config,
+    CONFIG_DIR,
+    CONFIG_FILE,
+)
+from hap_cli.core import app as app_mod
+from hap_cli.core import worksheet as ws_mod
+from hap_cli.core import record as rec_mod
+from hap_cli.core import workflow as wf_mod
+from hap_cli.core import flow_node as node_mod
+from hap_cli.core import instance as inst_mod
+from hap_cli.core import role as role_mod
+from hap_cli.utils.formatting import (
+    output_json,
+    output_table,
+    output_kv,
+    format_record_row,
+)
+from hap_cli.hap_cli import cli
+
+
+# ── Fixtures ─────────────────────────────────────────────────────────────
+
+
+@pytest.fixture
+def tmp_config(tmp_path, monkeypatch):
+    """Use a temporary config directory."""
+    config_dir = tmp_path / ".hap-cli"
+    config_file = config_dir / "config.json"
+    monkeypatch.setattr("hap_cli.core.session.CONFIG_DIR", config_dir)
+    monkeypatch.setattr("hap_cli.core.session.CONFIG_FILE", config_file)
+    return config_dir, config_file
+
+
+@pytest.fixture
+def mock_session():
+    """Create a configured mock session."""
+    session = Session(server_url="https://test.mingdao.com", auth_token="test_token_123")
+    return session
+
+
+def _mock_response(data, state=1):
+    """Create a mock requests.Response."""
+    resp = MagicMock()
+    resp.status_code = 200
+    resp.json.return_value = {"data": data, "state": state}
+    resp.raise_for_status = MagicMock()
+    return resp
+
+
+# ── Session Tests ────────────────────────────────────────────────────────
+
+
+class TestSession:
+    def test_load_empty_config(self, tmp_config):
+        session = Session.load()
+        assert session.server_url == ""
+        assert session.auth_token == ""
+        assert not session.is_configured()
+
+    def test_save_and_load_config(self, tmp_config):
+        config_dir, config_file = tmp_config
+        session = Session(server_url="https://test.com", auth_token="tok123")
+        session.default_app_id = "app1"
+        session.default_project_id = "proj1"
+        session.save()
+
+        assert config_file.exists()
+        loaded = Session.load()
+        assert loaded.server_url == "https://test.com"
+        assert loaded.auth_token == "tok123"
+        assert loaded.default_app_id == "app1"
+        assert loaded.default_project_id == "proj1"
+
+    def test_is_configured(self):
+        assert not Session().is_configured()
+        assert not Session(server_url="https://x.com").is_configured()
+        assert not Session(auth_token="tok").is_configured()
+        assert Session(server_url="https://x.com", auth_token="tok").is_configured()
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_api_call_success(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"id": "123", "name": "Test"})
+        result = mock_session.api_call("Worksheet", "GetWorksheetInfo", {"worksheetId": "ws1"})
+        assert result == {"id": "123", "name": "Test"}
+
+        call_args = mock_post.call_args
+        assert "api/Worksheet/GetWorksheetInfo" in call_args[0][0]
+        assert call_args[1]["json"] == {"worksheetId": "ws1"}
+        assert "md_pss_id test_token_123" in call_args[1]["headers"]["Authorization"]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_api_call_error_state(self, mock_post, mock_session):
+        resp = MagicMock()
+        resp.status_code = 200
+        resp.json.return_value = {"state": 0, "exception": "Not found"}
+        resp.raise_for_status = MagicMock()
+        mock_post.return_value = resp
+
+        with pytest.raises(APIError, match="Not found"):
+            mock_session.api_call("Worksheet", "GetWorksheetInfo", {})
+
+    def test_api_call_not_configured(self):
+        session = Session()
+        with pytest.raises(SessionError, match="not configured"):
+            session.api_call("Worksheet", "GetWorksheetInfo", {})
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_api_call_strips_trailing_slash(self, mock_post, mock_session):
+        mock_session.server_url = "https://test.com/"
+        mock_post.return_value = _mock_response({})
+        mock_session.api_call("Test", "Action", {})
+        url = mock_post.call_args[0][0]
+        assert "//api" not in url
+
+
+# ── App Tests ────────────────────────────────────────────────────────────
+
+
+class TestApp:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_app_info(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"appId": "a1", "name": "TestApp"})
+        result = app_mod.get_app_info(mock_session, "a1")
+        assert result["appId"] == "a1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_app_worksheets_list(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([
+            {"worksheetId": "ws1", "name": "Sheet1"},
+            {"worksheetId": "ws2", "name": "Sheet2"},
+        ])
+        result = app_mod.get_app_worksheets(mock_session, "a1")
+        assert len(result) == 2
+        assert result[0]["worksheetId"] == "ws1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_apps_for_project_list(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([
+            {"appId": "a1", "name": "App1"},
+        ])
+        result = app_mod.get_apps_for_project(mock_session, "proj1")
+        assert len(result) == 1
+
+
+# ── Worksheet Tests ──────────────────────────────────────────────────────
+
+
+class TestWorksheet:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_worksheet_info(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"worksheetId": "ws1", "name": "Test"})
+        result = ws_mod.get_worksheet_info(mock_session, "ws1")
+        assert result["name"] == "Test"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_worksheet_controls(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([
+            {"controlId": "c1", "controlName": "Name", "type": 2},
+        ])
+        result = ws_mod.get_worksheet_controls(mock_session, "ws1")
+        assert len(result) == 1
+        assert result[0]["controlName"] == "Name"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_worksheet_views(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([
+            {"viewId": "v1", "name": "Default"},
+        ])
+        result = ws_mod.get_worksheet_views(mock_session, "ws1")
+        assert len(result) == 1
+
+
+# ── Record Tests ─────────────────────────────────────────────────────────
+
+
+class TestRecord:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_records(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({
+            "data": [{"rowid": "r1"}, {"rowid": "r2"}],
+            "count": 2,
+        })
+        result = rec_mod.get_records(mock_session, "ws1", page_size=10)
+        assert result["count"] == 2
+        assert len(result["data"]) == 2
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_record(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"rowid": "r1", "c1": "val1"})
+        result = rec_mod.get_record(mock_session, "ws1", "r1")
+        assert result["rowid"] == "r1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_create_record(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"rowid": "r_new"})
+        result = rec_mod.create_record(
+            mock_session, "ws1",
+            [{"controlId": "c1", "value": "hello"}],
+        )
+        assert result["rowid"] == "r_new"
+        body = mock_post.call_args[1]["json"]
+        assert body["receiveControls"] == [{"controlId": "c1", "value": "hello"}]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_update_record(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        result = rec_mod.update_record(
+            mock_session, "ws1", "r1",
+            [{"controlId": "c1", "value": "updated"}],
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["rowId"] == "r1"
+        assert body["newOldControl"] == [{"controlId": "c1", "value": "updated"}]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_delete_records(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"isSuccess": True})
+        result = rec_mod.delete_records(mock_session, "ws1", ["r1", "r2"])
+        body = mock_post.call_args[1]["json"]
+        assert body["rowIds"] == ["r1", "r2"]
+
+
+# ── Workflow Tests ───────────────────────────────────────────────────────
+
+
+class TestWorkflow:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_process_list(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({
+            "list": [{"id": "wf1", "name": "Flow1"}],
+            "total": 1,
+        })
+        result = wf_mod.get_process_list(mock_session, "a1")
+        assert result["count"] == 1
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_create_process(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"processId": "wf_new"})
+        result = wf_mod.create_process(mock_session, "comp1", "My Flow", relation_id="app1")
+        body = mock_post.call_args[1]["json"]
+        assert body["companyId"] == "comp1"
+        assert body["name"] == "My Flow"
+        assert body["relationId"] == "app1"
+        assert result["processId"] == "wf_new"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_delete_process(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        wf_mod.delete_process(mock_session, "wf1")
+        body = mock_post.call_args[1]["json"]
+        assert body["processId"] == "wf1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_update_process(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        wf_mod.update_process(mock_session, "wf1", name="Renamed")
+        body = mock_post.call_args[1]["json"]
+        assert body["processId"] == "wf1"
+        assert body["name"] == "Renamed"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_copy_process(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"processId": "wf_copy"})
+        result = wf_mod.copy_process(mock_session, "wf1", "Copy of Flow")
+        body = mock_post.call_args[1]["json"]
+        assert body["processId"] == "wf1"
+        assert body["name"] == "Copy of Flow"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_publish(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        wf_mod.publish(mock_session, "wf1", is_publish=True)
+        body = mock_post.call_args[1]["json"]
+        assert body["processId"] == "wf1"
+        assert body["isPublish"] is True
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_publish_disable(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        wf_mod.publish(mock_session, "wf1", is_publish=False)
+        body = mock_post.call_args[1]["json"]
+        assert body["isPublish"] is False
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_rollback_version(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        wf_mod.rollback_version(mock_session, "wf1")
+        body = mock_post.call_args[1]["json"]
+        assert body["processId"] == "wf1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_process_config(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"executeType": 1, "allowRevoke": True})
+        result = wf_mod.get_process_config(mock_session, "wf1")
+        assert result["allowRevoke"] is True
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_process_config(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        wf_mod.save_process_config(mock_session, "wf1", {"allowRevoke": False, "executeType": 2})
+        body = mock_post.call_args[1]["json"]
+        assert body["processId"] == "wf1"
+        assert body["allowRevoke"] is False
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_start_process_by_id(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"instanceId": "inst1"})
+        result = wf_mod.start_process_by_id(mock_session, "wf1", source_id="r1")
+        body = mock_post.call_args[1]["json"]
+        assert body["processId"] == "wf1"
+        assert body["sourceId"] == "r1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_process_by_id(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"id": "wf1", "name": "Flow"})
+        result = wf_mod.get_process_by_id(mock_session, "wf1")
+        assert result["name"] == "Flow"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_version_history(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"version": 1}, {"version": 2}])
+        result = wf_mod.get_version_history(mock_session, "wf1")
+        assert isinstance(result, list)
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_move_process(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        wf_mod.move_process(mock_session, "wf1", "app2")
+        body = mock_post.call_args[1]["json"]
+        assert body["relationId"] == "app2"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_group_list(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"id": "g1", "name": "Group1"}])
+        result = wf_mod.get_group_list(mock_session, "app1")
+        assert len(result) == 1
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_create_group(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"id": "g_new"})
+        result = wf_mod.create_group(mock_session, "app1", "New Group")
+        body = mock_post.call_args[1]["json"]
+        assert body["name"] == "New Group"
+
+
+# ── FlowNode Tests ──────────────────────────────────────────────────────
+
+
+class TestFlowNode:
+    @patch("hap_cli.core.session.requests.post")
+    def test_add_node(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"nodeId": "n_new"})
+        result = node_mod.add_node(mock_session, "wf1", 4, name="Approval")
+        body = mock_post.call_args[1]["json"]
+        assert body["processId"] == "wf1"
+        assert body["flowNodeType"] == 4
+        assert body["name"] == "Approval"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_delete_node(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.delete_node(mock_session, "wf1", "n1")
+        body = mock_post.call_args[1]["json"]
+        assert body["nodeId"] == "n1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_nodes(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"startId": "n0", "nodes": []})
+        result = node_mod.get_nodes(mock_session, "wf1")
+        assert "startId" in result
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_node_detail(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"nodeId": "n1", "flowNodeType": 4})
+        result = node_mod.get_node_detail(mock_session, "wf1", "n1")
+        assert result["flowNodeType"] == 4
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_update_node_name(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.update_node_name(mock_session, "wf1", "n1", "New Name")
+        body = mock_post.call_args[1]["json"]
+        assert body["name"] == "New Name"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_update_node_desc(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.update_node_desc(mock_session, "wf1", "n1", desc="A desc", alias="Alias1")
+        body = mock_post.call_args[1]["json"]
+        assert body["desc"] == "A desc"
+        assert body["alias"] == "Alias1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_node(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        config = {"accounts": [{"accountId": "u1"}], "condition": "auto"}
+        node_mod.save_node(mock_session, "wf1", "n1", 4, config, name="Approval")
+        body = mock_post.call_args[1]["json"]
+        assert body["processId"] == "wf1"
+        assert body["flowNodeType"] == 4
+        assert body["accounts"] == [{"accountId": "u1"}]
+        assert body["name"] == "Approval"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_test_code(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"output": "Hello"})
+        result = node_mod.test_code(
+            mock_session, "wf1", "n1", "return 'Hello'",
+            input_data=[{"name": "x", "value": "1", "type": "number"}],
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["code"] == "return 'Hello'"
+        assert body["inputDatas"][0]["name"] == "x"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_test_webhook(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"status": 200, "body": "{}"})
+        result = node_mod.test_webhook(
+            mock_session, "wf1", "n1", "https://example.com/api",
+            method="GET", headers=[{"name": "X-Key", "value": "abc"}],
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["url"] == "https://example.com/api"
+        assert body["method"] == "GET"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_test_aigc(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"text": "AI response"})
+        result = node_mod.test_aigc(
+            mock_session, "wf1", "n1", "Summarize this",
+            model="gpt-4", system_message="You are helpful", temperature=0.5,
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["prompt"] == "Summarize this"
+        assert body["model"] == "gpt-4"
+        assert body["temperature"] == 0.5
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_json_to_controls(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"controlId": "auto1"}])
+        result = node_mod.json_to_controls(mock_session, '{"name": "test"}')
+        body = mock_post.call_args[1]["json"]
+        assert body["json"] == '{"name": "test"}'
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_code_template_list(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"id": "t1", "name": "Template1"}])
+        result = node_mod.get_code_template_list(mock_session, keyword="test")
+        body = mock_post.call_args[1]["json"]
+        assert body["keyword"] == "test"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_create_code_template(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"id": "t_new"})
+        result = node_mod.create_code_template(mock_session, "My Tmpl", "console.log('hi')")
+        body = mock_post.call_args[1]["json"]
+        assert body["name"] == "My Tmpl"
+        assert body["code"] == "console.log('hi')"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_sub_process_list(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"id": "sub1"}])
+        result = node_mod.get_sub_process_list(mock_session, "wf1")
+        body = mock_post.call_args[1]["json"]
+        assert body["processId"] == "wf1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_add_node_with_action_id(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"nodeId": "n_act"})
+        node_mod.add_node(mock_session, "wf1", 6, name="Add Record", action_id="1")
+        body = mock_post.call_args[1]["json"]
+        assert body["flowNodeType"] == 6
+        assert body["actionId"] == "1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_action_node_add_record(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        fields = [{"fieldId": "c001", "type": 2, "fieldValue": "hello"}]
+        node_mod.save_action_node(
+            mock_session, "wf1", "n1", "1", "ws_abc",
+            fields=fields, name="Add Record",
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["flowNodeType"] == 6
+        assert body["actionId"] == "1"
+        assert body["appId"] == "ws_abc"
+        assert body["appType"] == 1
+        assert body["fields"][0]["fieldId"] == "c001"
+        assert body["name"] == "Add Record"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_action_node_edit_record(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.save_action_node(
+            mock_session, "wf1", "n1", "2", "ws_abc",
+            select_node_id="src_node",
+            fields=[{"fieldId": "c001", "type": 2, "fieldValue": "updated"}],
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["actionId"] == "2"
+        assert body["selectNodeId"] == "src_node"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_action_node_delete_record(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.save_action_node(
+            mock_session, "wf1", "n1", "3", "ws_abc",
+            select_node_id="src_node",
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["actionId"] == "3"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_search_node_worksheet_find(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        cond = [{"fieldId": "c001", "conditionId": "1", "value": ["test"]}]
+        node_mod.save_search_node(
+            mock_session, "wf1", "n1", "406",
+            app_id="ws_abc", operate_condition=cond,
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["flowNodeType"] == 7
+        assert body["actionId"] == "406"
+        assert body["appId"] == "ws_abc"
+        assert body["operateCondition"][0]["fieldId"] == "c001"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_search_node_find_and_update(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.save_search_node(
+            mock_session, "wf1", "n1", "421",
+            app_id="ws_abc",
+            fields=[{"fieldId": "c002", "type": 2, "fieldValue": "new"}],
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["actionId"] == "421"
+        assert body["fields"][0]["fieldValue"] == "new"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_search_node_execute_type(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.save_search_node(
+            mock_session, "wf1", "n1", "406",
+            app_id="ws_abc", execute_type=2, random=True,
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["executeType"] == 2
+        assert body["random"] is True
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_get_more_record_from_worksheet(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.save_get_more_record_node(
+            mock_session, "wf1", "n1", "400",
+            app_id="ws_abc",
+            sorts=[{"fieldId": "c001", "isAsc": True}],
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["flowNodeType"] == 13
+        assert body["actionId"] == "400"
+        assert body["appId"] == "ws_abc"
+        assert body["sorts"][0]["isAsc"] is True
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_get_more_record_batch_update(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.save_get_more_record_node(
+            mock_session, "wf1", "n1", "412",
+            app_id="ws_abc",
+            fields=[{"fieldId": "c001", "type": 2, "fieldValue": "batch"}],
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["actionId"] == "412"
+        assert body["fields"][0]["fieldValue"] == "batch"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_get_more_record_batch_delete(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.save_get_more_record_node(
+            mock_session, "wf1", "n1", "413",
+            app_id="ws_abc",
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["actionId"] == "413"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_get_more_record_with_limit(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        node_mod.save_get_more_record_node(
+            mock_session, "wf1", "n1", "400",
+            app_id="ws_abc",
+            number_field_value={"fieldValue": 100},
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["numberFieldValue"]["fieldValue"] == 100
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_app_template_controls(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"controlId": "c001", "controlName": "Name"}])
+        result = node_mod.get_app_template_controls(mock_session, "wf1", "n1", "ws_abc")
+        body = mock_post.call_args[1]["json"]
+        assert body["appId"] == "ws_abc"
+        assert body["appType"] == 1
+        assert result[0]["controlId"] == "c001"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_node_type_constants(self, mock_post, mock_session):
+        assert node_mod.NODE_TYPE["ACTION"] == 6
+        assert node_mod.NODE_TYPE["SEARCH"] == 7
+        assert node_mod.NODE_TYPE["GET_MORE_RECORD"] == 13
+        assert node_mod.NODE_TYPE["AIGC"] == 31
+        assert node_mod.NODE_TYPE["LOOP"] == 29
+
+    def test_action_id_constants(self, mock_session):
+        assert node_mod.ACTION_ID["ADD_RECORD"] == "1"
+        assert node_mod.ACTION_ID["EDIT_RECORD"] == "2"
+        assert node_mod.ACTION_ID["DELETE_RECORD"] == "3"
+        assert node_mod.ACTION_ID["WORKSHEET_FIND"] == "406"
+        assert node_mod.ACTION_ID["BATCH_UPDATE"] == "412"
+        assert node_mod.ACTION_ID["BATCH_DELETE"] == "413"
+        assert node_mod.ACTION_ID["FROM_WORKSHEET"] == "400"
+
+
+# ── Instance Tests ──────────────────────────────────────────────────────
+
+
+class TestInstance:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_todo_count(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"waitingApproval": 3, "waitingFill": 1})
+        result = inst_mod.get_todo_count(mock_session)
+        assert result["waitingApproval"] == 3
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_todo_list(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({
+            "list": [{"id": "inst1", "title": "Task1"}],
+            "total": 1,
+        })
+        result = inst_mod.get_todo_list(mock_session, type_=4)
+        assert result["count"] == 1
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_instance_detail(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"id": "inst1", "status": 1})
+        result = inst_mod.get_instance_detail(mock_session, "inst1")
+        assert result["status"] == 1
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_approve(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        inst_mod.approve(mock_session, "inst1", work_id="w1", opinion="LGTM")
+        body = mock_post.call_args[1]["json"]
+        assert body["id"] == "inst1"
+        assert body["workId"] == "w1"
+        assert body["opinion"] == "LGTM"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_reject(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        inst_mod.reject(mock_session, "inst1", opinion="Not ready", back_node_id="n0")
+        body = mock_post.call_args[1]["json"]
+        assert body["opinion"] == "Not ready"
+        assert body["backNodeId"] == "n0"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_forward(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        inst_mod.forward(mock_session, "inst1", "user2", opinion="Please review")
+        body = mock_post.call_args[1]["json"]
+        assert body["forwardAccountId"] == "user2"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_sign_task(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        inst_mod.sign_task(mock_session, "inst1", "user3", before=False)
+        body = mock_post.call_args[1]["json"]
+        assert body["forwardAccountId"] == "user3"
+        assert body["before"] is False
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_submit(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        inst_mod.submit(mock_session, "inst1", work_id="w1")
+        body = mock_post.call_args[1]["json"]
+        assert body["id"] == "inst1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_revoke(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        inst_mod.revoke(mock_session, "inst1")
+        body = mock_post.call_args[1]["json"]
+        assert body["id"] == "inst1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_urge(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        inst_mod.urge(mock_session, "inst1", work_id="w1")
+        body = mock_post.call_args[1]["json"]
+        assert body["operationType"] == 18
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_end_instance(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        inst_mod.end_instance(mock_session, "inst1")
+        body = mock_post.call_args[1]["json"]
+        assert body["instanceId"] == "inst1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_reset_instance(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        inst_mod.reset_instance(mock_session, "inst1")
+        body = mock_post.call_args[1]["json"]
+        assert body["instanceId"] == "inst1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_history_list(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({
+            "list": [{"instanceId": "inst1", "status": 2}],
+            "total": 1,
+        })
+        result = inst_mod.get_history_list(mock_session, process_id="wf1", status=2)
+        assert result["count"] == 1
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_history_detail(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"instanceId": "inst1", "nodes": []})
+        result = inst_mod.get_history_detail(mock_session, "inst1")
+        assert result["instanceId"] == "inst1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_operation_history(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"action": "pass", "time": "2024-01-01"}])
+        result = inst_mod.get_operation_history(mock_session, "inst1")
+        assert len(result) == 1
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_batch_operation(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"success": 5})
+        result = inst_mod.batch_operation(
+            mock_session, 4, process_id="wf1", selects=["s1", "s2"],
+        )
+        body = mock_post.call_args[1]["json"]
+        assert body["batchOperationType"] == 4
+        assert body["selects"] == ["s1", "s2"]
+
+
+# ── Role Tests ───────────────────────────────────────────────────────────
+
+
+class TestRole:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_roles(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([
+            {"roleId": "role1", "name": "Admin"},
+        ])
+        result = role_mod.get_roles(mock_session, "a1")
+        assert len(result) == 1
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_create_role(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"roleId": "role_new"})
+        result = role_mod.create_role(mock_session, "a1", "Viewer", "Read-only", 10)
+        body = mock_post.call_args[1]["json"]
+        assert body["name"] == "Viewer"
+        assert body["permissionWay"] == 10
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_delete_role(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        role_mod.delete_role(mock_session, "a1", "role1", "role2")
+        body = mock_post.call_args[1]["json"]
+        assert body["roleId"] == "role1"
+        assert body["resultRoleId"] == "role2"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_add_role_members(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        role_mod.add_role_members(mock_session, "a1", "role1", user_ids=["u1", "u2"])
+        body = mock_post.call_args[1]["json"]
+        assert body["userIds"] == ["u1", "u2"]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_remove_role_members(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        role_mod.remove_role_members(mock_session, "a1", "role1", department_ids=["d1"])
+        body = mock_post.call_args[1]["json"]
+        assert body["departmentIds"] == ["d1"]
+
+
+# ── Formatting Tests ─────────────────────────────────────────────────────
+
+
+class TestFormatting:
+    def test_output_json(self, capsys):
+        output_json({"key": "value", "num": 42})
+        captured = capsys.readouterr()
+        data = json.loads(captured.out)
+        assert data["key"] == "value"
+        assert data["num"] == 42
+
+    def test_output_table(self, capsys):
+        rows = [
+            {"id": "1", "name": "Alice"},
+            {"id": "2", "name": "Bob"},
+        ]
+        output_table(rows, ["id", "name"], ["ID", "Name"])
+        captured = capsys.readouterr()
+        assert "Alice" in captured.out
+        assert "Bob" in captured.out
+        assert "ID" in captured.out
+
+    def test_output_table_empty(self, capsys):
+        output_table([], ["id"], ["ID"])
+        captured = capsys.readouterr()
+        assert "no data" in captured.out
+
+    def test_format_record_row_basic(self):
+        record = {"rowid": "r1", "c1": "hello", "c2": "world"}
+        result = format_record_row(record)
+        assert result["rowId"] == "r1"
+        assert result["c1"] == "hello"
+
+    def test_format_record_row_with_controls(self):
+        record = {"rowid": "r1", "c1": "hello"}
+        controls = [{"controlId": "c1", "controlName": "Name"}]
+        result = format_record_row(record, controls)
+        assert "Name" in result
+        assert result["Name"] == "hello"
+
+    def test_format_record_row_json_array(self):
+        record = {"rowid": "r1", "c1": json.dumps([{"name": "A"}, {"name": "B"}])}
+        result = format_record_row(record)
+        assert result["c1"] == "A, B"
+
+
+# ── Auth Tests ───────────────────────────────────────────────────────────
+
+
+class TestAuth:
+    def test_resolve_server_mingdao(self):
+        from hap_cli.core.auth import resolve_server
+        api, webui = resolve_server("mingdao")
+        assert api == "https://www.mingdao.com/api"
+        assert webui == "https://www.mingdao.com"
+
+    def test_resolve_server_nocoly(self):
+        from hap_cli.core.auth import resolve_server
+        api, webui = resolve_server("nocoly")
+        assert api == "https://www.nocoly.com/wwwapi"
+        assert webui == "https://www.nocoly.com"
+
+    def test_resolve_server_self_hosted(self):
+        from hap_cli.core.auth import resolve_server
+        api, webui = resolve_server("https://hap.example.com")
+        assert api == "https://hap.example.com/wwwapi"
+        assert webui == "https://hap.example.com"
+
+    def test_resolve_server_trailing_slash(self):
+        from hap_cli.core.auth import resolve_server
+        api, webui = resolve_server("https://hap.example.com/")
+        assert api == "https://hap.example.com/wwwapi"
+        assert webui == "https://hap.example.com"
+
+    def test_build_auth_url(self):
+        from hap_cli.core.auth import build_auth_url
+        import base64
+        url = build_auth_url("https://www.mingdao.com", 5100)
+        assert url.startswith("https://www.mingdao.com/cliauth?p=")
+        # Decode and verify callback info
+        encoded = url.split("?p=")[1]
+        decoded = json.loads(base64.b64decode(encoded).decode())
+        assert decoded == {"url": "http://localhost:5100"}
+
+    def test_get_available_port(self):
+        from hap_cli.core.auth import get_available_port
+        port = get_available_port()
+        assert 5100 <= port < 5200
+
+    @patch("hap_cli.core.auth.requests.post")
+    def test_get_user_info_success(self, mock_post):
+        from hap_cli.core.auth import get_user_info
+        resp = MagicMock()
+        resp.json.return_value = {
+            "state": 1,
+            "data": {
+                "md.global": {
+                    "Account": {
+                        "accountId": "uid1",
+                        "fullname": "Test User",
+                        "email": "test@example.com",
+                        "avatar": "avatar.png",
+                        "lang": "zh-Hans",
+                    }
+                }
+            },
+        }
+        resp.raise_for_status = MagicMock()
+        mock_post.return_value = resp
+
+        info = get_user_info("https://www.mingdao.com/api", "tok123")
+        assert info["id"] == "uid1"
+        assert info["name"] == "Test User"
+        assert info["email"] == "test@example.com"
+        assert info["lang"] == "zh-Hans"
+
+        # Verify correct API call
+        call_args = mock_post.call_args
+        assert "/Global/GetGlobalMeta" in call_args[0][0]
+        assert call_args[1]["headers"]["Authorization"] == "md_pss_id tok123"
+
+    @patch("hap_cli.core.auth.requests.post")
+    def test_get_user_info_invalid_token(self, mock_post):
+        from hap_cli.core.auth import get_user_info
+        resp = MagicMock()
+        resp.json.return_value = {"state": 0, "exception": "Invalid token"}
+        resp.raise_for_status = MagicMock()
+        mock_post.return_value = resp
+
+        with pytest.raises(ValueError, match="Invalid token"):
+            get_user_info("https://www.mingdao.com/api", "bad_token")
+
+    def test_config_login_help(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["config", "login", "--help"])
+        assert result.exit_code == 0
+        assert "Login via browser" in result.output
+        assert "mingdao" in result.output
+
+    def test_config_logout(self, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        result = runner.invoke(cli, ["config", "logout"])
+        assert result.exit_code == 0
+        assert "Logged out" in result.output
+
+        # Verify token is cleared
+        result = runner.invoke(cli, ["--json", "config", "show"])
+        data = json.loads(result.output)
+        assert data["auth_token"] == ""
+        assert data["configured"] is False
+
+    @patch("hap_cli.core.auth.get_user_info")
+    def test_config_whoami(self, mock_user_info, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        mock_user_info.return_value = {
+            "id": "uid1", "name": "Test", "email": "t@e.com",
+            "avatar": "", "lang": "en",
+        }
+        result = runner.invoke(cli, ["--json", "config", "whoami"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["name"] == "Test"
+        assert data["email"] == "t@e.com"
+
+    def test_config_whoami_not_logged_in(self, tmp_config):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["config", "whoami"])
+        assert result.exit_code != 0
+
+
+# ── CLI Tests ────────────────────────────────────────────────────────────
+
+
+class TestCLI:
+    def test_help(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["--help"])
+        assert result.exit_code == 0
+        assert "MingDAO HAP" in result.output
+        assert "app" in result.output
+        assert "record" in result.output
+        assert "workflow" in result.output
+
+    def test_config_set_and_show(self, tmp_config):
+        runner = CliRunner()
+        result = runner.invoke(cli, [
+            "config", "set",
+            "--server", "https://test.com",
+            "--token", "tok123",
+        ])
+        assert result.exit_code == 0
+
+        result = runner.invoke(cli, ["config", "show"])
+        assert result.exit_code == 0
+        assert "test.com" in result.output
+
+    def test_config_show_json(self, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set",
+            "--server", "https://test.com",
+            "--token", "tok123",
+        ])
+        result = runner.invoke(cli, ["--json", "config", "show"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["server_url"] == "https://test.com"
+        assert data["configured"] is True
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_record_list(self, mock_post, tmp_config):
+        # First configure
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        mock_post.return_value = _mock_response({
+            "data": [{"rowid": "r1", "c1": "val"}],
+            "count": 1,
+        })
+        result = runner.invoke(cli, ["--json", "record", "list", "ws1"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["count"] == 1
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_worksheet_fields_json(self, mock_post, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        mock_post.return_value = _mock_response([
+            {"controlId": "c1", "controlName": "Title", "type": 2},
+        ])
+        result = runner.invoke(cli, ["--json", "worksheet", "fields", "ws1"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert len(data) == 1
+        assert data[0]["controlName"] == "Title"
+
+    def test_missing_app_id_error(self, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        result = runner.invoke(cli, ["app", "worksheets"])
+        assert result.exit_code != 0
+
+    def test_help_includes_new_groups(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["--help"])
+        assert "node" in result.output
+        assert "instance" in result.output
+        assert "workflow" in result.output
+
+    def test_workflow_help(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["workflow", "--help"])
+        assert result.exit_code == 0
+        assert "create" in result.output
+        assert "publish" in result.output
+        assert "rollback" in result.output
+        assert "trigger" in result.output
+        assert "config-get" in result.output
+
+    def test_node_help(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["node", "--help"])
+        assert result.exit_code == 0
+        assert "add" in result.output
+        assert "save" in result.output
+        assert "test-code" in result.output
+        assert "test-webhook" in result.output
+        assert "test-ai" in result.output
+        assert "save-action" in result.output
+        assert "save-search" in result.output
+        assert "save-get-more" in result.output
+        assert "controls" in result.output
+        assert "types" in result.output
+
+    def test_node_types_command(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["node", "types"])
+        assert result.exit_code == 0
+        assert "ACTION" in result.output
+        assert "SEARCH" in result.output
+        assert "GET_MORE_RECORD" in result.output
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_node_save_action_cli(self, mock_post, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        mock_post.return_value = _mock_response(True)
+        result = runner.invoke(cli, [
+            "node", "save-action", "wf1", "n1",
+            "-a", "1", "--app-id", "ws_abc",
+            "-f", '[{"fieldId":"c001","type":2,"fieldValue":"hello"}]',
+        ])
+        assert result.exit_code == 0
+        assert "saved" in result.output.lower()
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_node_save_search_cli(self, mock_post, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        mock_post.return_value = _mock_response(True)
+        result = runner.invoke(cli, [
+            "node", "save-search", "wf1", "n1",
+            "-a", "406", "--app-id", "ws_abc",
+        ])
+        assert result.exit_code == 0
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_node_save_get_more_cli(self, mock_post, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        mock_post.return_value = _mock_response(True)
+        result = runner.invoke(cli, [
+            "node", "save-get-more", "wf1", "n1",
+            "-a", "400", "--app-id", "ws_abc",
+        ])
+        assert result.exit_code == 0
+
+    def test_instance_help(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["instance", "--help"])
+        assert result.exit_code == 0
+        assert "approve" in result.output
+        assert "reject" in result.output
+        assert "forward" in result.output
+        assert "todo" in result.output
+        assert "batch" in result.output
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_workflow_create_json(self, mock_post, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        mock_post.return_value = _mock_response({"processId": "wf_new"})
+        result = runner.invoke(cli, [
+            "--json", "workflow", "create",
+            "--company-id", "comp1", "--name", "Test Flow", "--app-id", "app1",
+        ])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["processId"] == "wf_new"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_node_list_json(self, mock_post, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        mock_post.return_value = _mock_response({"startId": "n0", "nodes": [{"id": "n1"}]})
+        result = runner.invoke(cli, ["--json", "node", "list", "wf1"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "startId" in data
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_instance_todo_json(self, mock_post, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, [
+            "config", "set", "--server", "https://t.com", "--token", "tok",
+        ])
+        mock_post.return_value = _mock_response({
+            "list": [{"id": "i1", "title": "Task"}], "total": 1,
+        })
+        result = runner.invoke(cli, ["--json", "instance", "todo"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["count"] == 1
+
+
+# ── Optionset Tests ───────────────────────────────────────────────────────
+
+
+class TestOptionset:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_collections(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"id": "os1", "name": "Status"}])
+        from hap_cli.core import optionset as os_mod
+        result = os_mod.get_collections(mock_session, "app1")
+        assert result == [{"id": "os1", "name": "Status"}]
+        args = mock_post.call_args
+        assert "Worksheet/GetCollectionsByAppId" in args[0][0]
+        assert args[1]["json"]["appId"] == "app1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_collection(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"id": "os1", "options": []})
+        from hap_cli.core import optionset as os_mod
+        result = os_mod.get_collection(mock_session, "os1")
+        assert result["id"] == "os1"
+        args = mock_post.call_args
+        assert "Worksheet/GetCollectionByCollectId" in args[0][0]
+        assert args[1]["json"]["collectId"] == "os1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_save_collection(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"id": "os1"})
+        from hap_cli.core import optionset as os_mod
+        result = os_mod.save_collection(mock_session, "app1", "Priority", [])
+        assert result["id"] == "os1"
+        args = mock_post.call_args
+        assert "Worksheet/SaveOptionsCollection" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_delete_collection(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import optionset as os_mod
+        result = os_mod.delete_collection(mock_session, "os1")
+        assert result is True
+        args = mock_post.call_args
+        assert "Worksheet/DeleteOptionsCollection" in args[0][0]
+        assert args[1]["json"]["collectId"] == "os1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_move_collection(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import optionset as os_mod
+        result = os_mod.move_collection(mock_session, "os1", "app2")
+        assert result is True
+        args = mock_post.call_args
+        assert "Worksheet/UpdateOptionsCollectionAppId" in args[0][0]
+        assert args[1]["json"]["collectId"] == "os1"
+        assert args[1]["json"]["appId"] == "app2"
+
+
+# ── Page Tests ────────────────────────────────────────────────────────────
+
+
+class TestPage:
+    def test_component_types(self):
+        from hap_cli.core.page import PAGE_COMPONENT_TYPES
+        assert "analysis" in PAGE_COMPONENT_TYPES
+        assert "button" in PAGE_COMPONENT_TYPES
+        assert len(PAGE_COMPONENT_TYPES) >= 6
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_copy_page(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"pageId": "pg2"})
+        from hap_cli.core import page as page_mod
+        result = page_mod.copy_page(mock_session, "app1", "pg1", "Copy of Page")
+        assert result["pageId"] == "pg2"
+        args = mock_post.call_args
+        assert "AppManagement/CopyCustomPage" in args[0][0]
+        assert args[1]["json"]["pageId"] == "pg1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_add_authorize(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"id": "auth1"})
+        from hap_cli.core import page as page_mod
+        result = page_mod.add_authorize(mock_session, "app1", "pg1", "role1")
+        assert result["id"] == "auth1"
+        args = mock_post.call_args
+        assert "AppManagement/AddAuthorize" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_authorizes(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"id": "auth1"}])
+        from hap_cli.core import page as page_mod
+        result = page_mod.get_authorizes(mock_session, "app1", "pg1")
+        assert result == [{"id": "auth1"}]
+        args = mock_post.call_args
+        assert "AppManagement/GetAuthorizes" in args[0][0]
+
+
+# ── Contact Tests ─────────────────────────────────────────────────────────
+
+
+class TestContact:
+    @patch("hap_cli.core.session.requests.post")
+    def test_search_contacts(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"accountId": "u1", "fullname": "Alice"}])
+        from hap_cli.core import contact as contact_mod
+        result = contact_mod.search_contacts(mock_session, "Alice", project_id="proj1")
+        assert result == [{"accountId": "u1", "fullname": "Alice"}]
+        args = mock_post.call_args
+        assert "AddressBook/SearchAddressbookAndDepartment" in args[0][0]
+        assert args[1]["json"]["keywords"] == "Alice"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_account_detail(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"accountId": "u1", "fullname": "Alice"})
+        from hap_cli.core import contact as contact_mod
+        result = contact_mod.get_account_detail(mock_session, "u1")
+        assert result["accountId"] == "u1"
+        args = mock_post.call_args
+        assert "AddressBook/GetAccountDetail" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_friends(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"accountId": "u2"}])
+        from hap_cli.core import contact as contact_mod
+        result = contact_mod.get_friends(mock_session)
+        assert result == [{"accountId": "u2"}]
+        args = mock_post.call_args
+        assert "AddressBook/GetAllAddressbook" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_add_friend(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import contact as contact_mod
+        result = contact_mod.add_friend(mock_session, "u2")
+        assert result is True
+        args = mock_post.call_args
+        assert "AddressBook/AddFriend" in args[0][0]
+        assert args[1]["json"]["accountId"] == "u2"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_accept_friend(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import contact as contact_mod
+        result = contact_mod.accept_friend(mock_session, "u2")
+        assert result is True
+        args = mock_post.call_args
+        assert "AddressBook/EditAgreeFriend" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_reject_friend(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import contact as contact_mod
+        result = contact_mod.reject_friend(mock_session, "u2")
+        assert result is True
+        args = mock_post.call_args
+        assert "AddressBook/EditRefuseFriend" in args[0][0]
+
+
+# ── Department Tests ──────────────────────────────────────────────────────
+
+
+class TestDepartment:
+    @patch("hap_cli.core.session.requests.post")
+    def test_list_departments(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"list": [{"departmentId": "d1"}], "total": 1})
+        from hap_cli.core import department as dept_mod
+        result = dept_mod.list_departments(mock_session, "proj1", "d0")
+        assert result["total"] == 1
+        args = mock_post.call_args
+        assert "Department/PagedSubDepartments" in args[0][0]
+        assert args[1]["json"]["projectId"] == "proj1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_department_info(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"departmentId": "d1", "departmentName": "HR"})
+        from hap_cli.core import department as dept_mod
+        result = dept_mod.get_department_info(mock_session, "d1")
+        assert result["departmentId"] == "d1"
+        args = mock_post.call_args
+        assert "Department/GetDepartmentInfo" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_create_department(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"departmentId": "d2"})
+        from hap_cli.core import department as dept_mod
+        result = dept_mod.create_department(mock_session, "proj1", "Engineering", parent_id="d0")
+        assert result["departmentId"] == "d2"
+        args = mock_post.call_args
+        assert "Department/AddDepartment" in args[0][0]
+        assert args[1]["json"]["departmentName"] == "Engineering"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_delete_departments(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import department as dept_mod
+        result = dept_mod.delete_departments(mock_session, "proj1", ["d1", "d2"])
+        assert result is True
+        args = mock_post.call_args
+        assert "Department/DeleteDepartments" in args[0][0]
+        assert "d1" in args[1]["json"]["departmentIds"]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_department_users(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"accountId": "u1"}])
+        from hap_cli.core import department as dept_mod
+        result = dept_mod.get_department_users(mock_session, "proj1", "d1")
+        assert result == [{"accountId": "u1"}]
+        args = mock_post.call_args
+        assert "Department/GetProjectDepartmentUsers" in args[0][0]
+
+
+# ── Post Tests ────────────────────────────────────────────────────────────
+
+
+class TestPost:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_post_list(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"list": [{"postId": "p1"}], "total": 1})
+        from hap_cli.core import post as post_mod
+        result = post_mod.get_post_list(mock_session, "proj1")
+        assert result["total"] == 1
+        args = mock_post.call_args
+        assert "Post/GetPostList" in args[0][0]
+        assert args[1]["json"]["projectId"] == "proj1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_post_detail(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"postId": "p1", "message": "Hello"})
+        from hap_cli.core import post as post_mod
+        result = post_mod.get_post_detail(mock_session, "p1")
+        assert result["postId"] == "p1"
+        args = mock_post.call_args
+        assert "Post/GetPostDetail" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_add_post(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"postId": "p2"})
+        from hap_cli.core import post as post_mod
+        result = post_mod.add_post(mock_session, "proj1", 1, "Hello World")
+        assert result["postId"] == "p2"
+        args = mock_post.call_args
+        assert "Post/AddPost" in args[0][0]
+        assert args[1]["json"]["postMsg"] == "Hello World"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_add_comment(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"commentId": "c1"})
+        from hap_cli.core import post as post_mod
+        result = post_mod.add_comment(mock_session, "p1", "Great post!")
+        assert result["commentId"] == "c1"
+        args = mock_post.call_args
+        assert "Post/AddPostComment" in args[0][0]
+        assert args[1]["json"]["message"] == "Great post!"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_like_post(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import post as post_mod
+        result = post_mod.like_post(mock_session, "p1")
+        assert result is True
+        args = mock_post.call_args
+        assert "Post/Like" in args[0][0]
+
+
+# ── Calendar Tests ────────────────────────────────────────────────────────
+
+
+class TestCalendar:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_calendars(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"calendarId": "cal1"}])
+        from hap_cli.core import calendar_mod
+        result = calendar_mod.get_calendars(mock_session, "2026-01-01", "2026-12-31")
+        assert result == [{"calendarId": "cal1"}]
+        args = mock_post.call_args
+        assert "Calendar/GetCalendars" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_insert_calendar(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"calendarId": "cal2"})
+        from hap_cli.core import calendar_mod
+        result = calendar_mod.insert_calendar(mock_session, "Team Meetings", "2026-01-01", "2026-01-02")
+        assert result["calendarId"] == "cal2"
+        args = mock_post.call_args
+        assert "Calendar/InsertCalendar" in args[0][0]
+        assert args[1]["json"]["name"] == "Team Meetings"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_delete_calendar(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import calendar_mod
+        result = calendar_mod.delete_calendar(mock_session, "cal1")
+        assert result is True
+        args = mock_post.call_args
+        assert "Calendar/DeleteCalendar" in args[0][0]
+        assert args[1]["json"]["calendarId"] == "cal1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_categories(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"categoryId": "cat1"}])
+        from hap_cli.core import calendar_mod
+        result = calendar_mod.get_categories(mock_session)
+        assert result == [{"categoryId": "cat1"}]
+        args = mock_post.call_args
+        assert "Calendar/GetUserAllCalCategories" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_add_members(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import calendar_mod
+        result = calendar_mod.add_members(mock_session, "cal1", ["u1", "u2"])
+        assert result is True
+        args = mock_post.call_args
+        assert "Calendar/AddMembers" in args[0][0]
+        assert "u1" in args[1]["json"]["memberIds"]
+
+
+# ── Chat Tests ────────────────────────────────────────────────────────────
+
+
+class TestChat:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_chat_list(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"chatId": "ch1"}])
+        from hap_cli.core import chat as chat_mod
+        result = chat_mod.get_chat_list(mock_session)
+        assert result == [{"chatId": "ch1"}]
+        args = mock_post.call_args
+        assert "Chat/GetChatList" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_send_message(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"msgId": "m1"})
+        from hap_cli.core import chat as chat_mod
+        result = chat_mod.send_message(mock_session, ["u1", "u2"], "Hello!")
+        assert result["msgId"] == "m1"
+        args = mock_post.call_args
+        assert "Message/SendMessageToAccountIds" in args[0][0]
+        assert args[1]["json"]["message"] == "Hello!"
+        assert "u1" in args[1]["json"]["accountIds"]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_group_info(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"groupId": "g1", "name": "Dev Team"})
+        from hap_cli.core import chat as chat_mod
+        result = chat_mod.get_group_info(mock_session, "g1")
+        assert result["groupId"] == "g1"
+        args = mock_post.call_args
+        assert "Chat/GetGroupInfo" in args[0][0]
+        assert args[1]["json"]["groupId"] == "g1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_send_card(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"msgId": "m2"})
+        from hap_cli.core import chat as chat_mod
+        result = chat_mod.send_card(mock_session, "g1", {"title": "Alert"})
+        assert result["msgId"] == "m2"
+        args = mock_post.call_args
+        assert "Chat/SendCardToChat" in args[0][0]
+
+
+# ── Group Tests ───────────────────────────────────────────────────────────
+
+
+class TestGroup:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_groups(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"list": [{"groupId": "gr1"}], "total": 1})
+        from hap_cli.core import group as group_mod
+        result = group_mod.get_groups(mock_session, "proj1")
+        assert result["total"] == 1
+        args = mock_post.call_args
+        assert "Group/GetGroups" in args[0][0]
+        assert args[1]["json"]["projectId"] == "proj1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_group_info(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"groupId": "gr1", "name": "Frontend"})
+        from hap_cli.core import group as group_mod
+        result = group_mod.get_group_info(mock_session, "gr1")
+        assert result["groupId"] == "gr1"
+        args = mock_post.call_args
+        assert "Group/GetGroupInfo" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_add_group(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"groupId": "gr2"})
+        from hap_cli.core import group as group_mod
+        result = group_mod.add_group(mock_session, "proj1", "Backend", about="Backend team")
+        assert result["groupId"] == "gr2"
+        args = mock_post.call_args
+        assert "Group/AddGroup" in args[0][0]
+        assert args[1]["json"]["groupName"] == "Backend"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_remove_group(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import group as group_mod
+        result = group_mod.remove_group(mock_session, "gr1")
+        assert result is True
+        args = mock_post.call_args
+        assert "Group/RemoveGroup" in args[0][0]
+        assert args[1]["json"]["groupId"] == "gr1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_remove_user(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import group as group_mod
+        result = group_mod.remove_user(mock_session, "gr1", "u1")
+        assert result is True
+        args = mock_post.call_args
+        assert "Group/RemoveUser" in args[0][0]
+        assert args[1]["json"]["accountId"] == "u1"
+
+
+# ── AI Tests ──────────────────────────────────────────────────────────────
+
+
+class TestAI:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_assistants(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"list": [{"assistantId": "a1"}], "total": 1})
+        from hap_cli.core import ai as ai_mod
+        result = ai_mod.get_assistants(mock_session, "proj1")
+        assert result["total"] == 1
+        args = mock_post.call_args
+        assert "Assistant/GetList" in args[0][0]
+        assert args[1]["json"]["projectId"] == "proj1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_assistant(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"assistantId": "a1", "name": "Bot"})
+        from hap_cli.core import ai as ai_mod
+        result = ai_mod.get_assistant(mock_session, "a1")
+        assert result["assistantId"] == "a1"
+        args = mock_post.call_args
+        assert "Assistant/Get" in args[0][0]
+        assert args[1]["json"]["assistantId"] == "a1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_upsert_assistant(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"assistantId": "a2"})
+        from hap_cli.core import ai as ai_mod
+        config = {"name": "NewBot", "projectId": "proj1"}
+        result = ai_mod.upsert_assistant(mock_session, config)
+        assert result["assistantId"] == "a2"
+        args = mock_post.call_args
+        assert "Assistant/Upsert" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_delete_assistant(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import ai as ai_mod
+        result = ai_mod.delete_assistant(mock_session, "a1")
+        assert result is True
+        args = mock_post.call_args
+        assert "Assistant/Delete" in args[0][0]
+        assert args[1]["json"]["assistantId"] == "a1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_set_assistant_status(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import ai as ai_mod
+        result = ai_mod.set_assistant_status(mock_session, "a1", 1)
+        assert result is True
+        args = mock_post.call_args
+        assert "Assistant/SetStatus" in args[0][0]
+        assert args[1]["json"]["status"] == 1
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_knowledge_bases(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"knowledgeBaseId": "kb1"}])
+        from hap_cli.core import ai as ai_mod
+        result = ai_mod.get_knowledge_bases(mock_session, "proj1")
+        assert result == [{"knowledgeBaseId": "kb1"}]
+        args = mock_post.call_args
+        assert "Assistant/GetListKnowledgeBase" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_upsert_knowledge_base(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"knowledgeBaseId": "kb2"})
+        from hap_cli.core import ai as ai_mod
+        config = {"name": "Docs KB", "projectId": "proj1"}
+        result = ai_mod.upsert_knowledge_base(mock_session, config)
+        assert result["knowledgeBaseId"] == "kb2"
+        args = mock_post.call_args
+        assert "Assistant/UpsertKnowledgeBase" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_chatbot_config(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"processId": "wf1", "enabled": True})
+        from hap_cli.core import ai as ai_mod
+        result = ai_mod.get_chatbot_config(mock_session, "wf1")
+        assert result["processId"] == "wf1"
+        args = mock_post.call_args
+        assert "workflow/getChatbotConfig" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_ai_service_status(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"enabled": True})
+        from hap_cli.core import ai as ai_mod
+        result = ai_mod.get_ai_service_status(mock_session, "proj1")
+        assert result["enabled"] is True
+        args = mock_post.call_args
+        assert "AIService/GetAIServiceStatus" in args[0][0]
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_models(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"modelId": "gpt4"}])
+        from hap_cli.core import ai as ai_mod
+        result = ai_mod.get_models(mock_session, "proj1")
+        assert result == [{"modelId": "gpt4"}]
+        args = mock_post.call_args
+        assert "AIService/GetDeveloperWithModes" in args[0][0]
+
+
+# ── Plugin Tests ──────────────────────────────────────────────────────────
+
+
+class TestPlugin:
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_plugins(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"list": [{"id": "pl1"}], "total": 1})
+        from hap_cli.core import plugin as plugin_mod
+        result = plugin_mod.get_plugins(mock_session, "proj1")
+        assert result["total"] == 1
+        args = mock_post.call_args
+        assert "Plugin/getList" in args[0][0]
+        assert args[1]["json"]["projectId"] == "proj1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_plugin_detail(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"id": "pl1", "name": "MyPlugin"})
+        from hap_cli.core import plugin as plugin_mod
+        result = plugin_mod.get_plugin_detail(mock_session, "pl1")
+        assert result["id"] == "pl1"
+        args = mock_post.call_args
+        assert "Plugin/getDetail" in args[0][0]
+        assert args[1]["json"]["id"] == "pl1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_create_plugin(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"id": "pl2"})
+        from hap_cli.core import plugin as plugin_mod
+        result = plugin_mod.create_plugin(mock_session, "proj1", "NewPlugin", description="Desc")
+        assert result["id"] == "pl2"
+        args = mock_post.call_args
+        assert "Plugin/create" in args[0][0]
+        assert args[1]["json"]["name"] == "NewPlugin"
+        assert args[1]["json"]["description"] == "Desc"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_edit_plugin(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import plugin as plugin_mod
+        result = plugin_mod.edit_plugin(mock_session, "pl1", name="Updated", description="NewDesc")
+        assert result is True
+        args = mock_post.call_args
+        assert "Plugin/edit" in args[0][0]
+        assert args[1]["json"]["name"] == "Updated"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_remove_plugin(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import plugin as plugin_mod
+        result = plugin_mod.remove_plugin(mock_session, "pl1")
+        assert result is True
+        args = mock_post.call_args
+        assert "Plugin/remove" in args[0][0]
+        assert args[1]["json"]["id"] == "pl1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_release_plugin(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response({"versionId": "v2"})
+        from hap_cli.core import plugin as plugin_mod
+        result = plugin_mod.release_plugin(mock_session, "pl1")
+        assert result["versionId"] == "v2"
+        args = mock_post.call_args
+        assert "Plugin/release" in args[0][0]
+        assert args[1]["json"]["id"] == "pl1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_rollback_plugin(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response(True)
+        from hap_cli.core import plugin as plugin_mod
+        result = plugin_mod.rollback_plugin(mock_session, "pl1", "v1")
+        assert result is True
+        args = mock_post.call_args
+        assert "Plugin/rollback" in args[0][0]
+        assert args[1]["json"]["versionId"] == "v1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_get_release_history(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"versionId": "v1"}, {"versionId": "v2"}])
+        from hap_cli.core import plugin as plugin_mod
+        result = plugin_mod.get_release_history(mock_session, "pl1")
+        assert len(result) == 2
+        args = mock_post.call_args
+        assert "Plugin/getReleaseHistory" in args[0][0]
+
+
+class TestConfigOrgs:
+    @patch("hap_cli.core.session.requests.post")
+    def test_orgs_list(self, mock_post, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, ["config", "set", "--server", "https://t.com", "--token", "tok"])
+        mock_post.return_value = _mock_response([
+            {"projectId": "p1", "companyName": "Acme Corp", "roleName": "Admin"},
+            {"projectId": "p2", "companyName": "Beta Inc", "roleName": "Member"},
+        ])
+        result = runner.invoke(cli, ["config", "orgs"])
+        assert result.exit_code == 0
+        assert "p1" in result.output
+        assert "Acme Corp" in result.output
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_orgs_json(self, mock_post, tmp_config):
+        runner = CliRunner()
+        runner.invoke(cli, ["config", "set", "--server", "https://t.com", "--token", "tok"])
+        mock_post.return_value = _mock_response([
+            {"projectId": "p1", "companyName": "Acme Corp"},
+        ])
+        result = runner.invoke(cli, ["--json", "config", "orgs"])
+        assert result.exit_code == 0
+        import json as _json
+        data = _json.loads(result.output)
+        assert data[0]["projectId"] == "p1"
+
+    @patch("hap_cli.core.session.requests.post")
+    def test_orgs_api_call(self, mock_post, mock_session):
+        mock_post.return_value = _mock_response([{"projectId": "p1"}])
+        mock_session.api_call("Account", "GetProjectList", {})
+        args = mock_post.call_args
+        assert "Account/GetProjectList" in args[0][0]