meshbook-cli 0.2.0__tar.gz → 0.4.0__tar.gz

{meshbook_cli-0.2.0 → meshbook_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshbook-cli
-Version: 0.2.0
+Version: 0.4.0
 Summary: Small-model-friendly CLI for meshbook.org — built so non-humans of any size can run a CRM.
 Project-URL: Homepage, https://meshbook.org
 Project-URL: Documentation, https://meshbook.org/docs

{meshbook_cli-0.2.0 → meshbook_cli-0.4.0}/mesh/cli.py

@@ -49,7 +49,7 @@ import urllib.parse
 import urllib.request
 from pathlib import Path
 
-VERSION = "0.2.0"
+VERSION = "0.4.0"
 DEFAULT_BASE = os.environ.get("MESHBOOK_BASE", "https://meshbook.org")
 
 
@@ -165,6 +165,18 @@ def _data(payload: dict) -> object:
     return payload
 
 
+def _items(payload: object) -> list:
+    """Normalise a list response through the envelope to a plain list.
+
+    Handles all three shapes the API emits: a bare list, {data: [...]},
+    and the ok_list paginated shape {data: {items: [...], total}}.
+    """
+    data = payload.get("data", payload) if isinstance(payload, dict) else payload
+    if isinstance(data, dict) and "items" in data:
+        data = data["items"]
+    return data or []
+
+
 # ─── command implementations ───────────────────────────────────────────
 
 
@@ -374,6 +386,10 @@ def cmd_chat_post(args, cfg: dict) -> int:
         return 2
     mesh_id = cfg["active_mesh_id"]
     body = {"bodyMd": args.message}
+    if getattr(args, "reply_to", None):
+        # Entity-chat threading: the server accepts parentMessageId
+        # (also replyToId) on the mesh-chat POST.
+        body["parentMessageId"] = args.reply_to
     payload = _api_call(
         "POST", f"/api/entities/mesh/{mesh_id}/chat", cfg=cfg, body=body
     )
@@ -814,6 +830,333 @@ def cmd_notifications(args, cfg: dict) -> int:
     return 0
 
 
+# ─── §31 batch 2: CRM verbs (leads / tasks / projects / companies) ─────
+#
+# Batch 1 (v0.2.0) gave non-humans channels + DMs + reactions. Batch 2
+# (v0.3.0) adds the daily-driver CRM verbs so the CLI is a full working
+# client, not just a chat tool: read + create across the four core
+# entities, plus lead stage-moves and task completion, plus read access
+# to custom-field definitions and saved views. Same auth + envelope
+# contract; every list uses _items() for envelope normalisation.
+
+
+def cmd_leads_list(args, cfg: dict) -> int:
+    params = {
+        "limit": args.limit, "pipelineId": args.pipeline,
+        "stageId": args.stage, "companyId": args.company,
+    }
+    items = _items(_api_call("GET", "/api/leads", cfg=cfg, params=params))
+    if args.json:
+        print(json.dumps(items, indent=2))
+        return 0
+    for ld in items:
+        val = ld.get("valueAmount")
+        money = f"  {val} {ld.get('currency', '')}".rstrip() if val is not None else ""
+        stage = ld.get("stageName") or ld.get("stageId") or ""
+        print(f"  {ld.get('title')}{money}  [{stage}]   {ld.get('id')}")
+    return 0
+
+
+def cmd_leads_create(args, cfg: dict) -> int:
+    body = {"title": args.title, "pipelineId": args.pipeline, "stageId": args.stage}
+    if args.value is not None:
+        body["valueAmount"] = args.value
+    if args.description:
+        body["description"] = args.description
+    data = _data(_api_call("POST", "/api/leads", cfg=cfg, body=body))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Created lead: {data.get('title')} ({data.get('id')})")
+    return 0
+
+
+def cmd_leads_move(args, cfg: dict) -> int:
+    data = _data(_api_call(
+        "POST", f"/api/leads/{args.lead_id}/move-stage",
+        cfg=cfg, body={"stageId": args.stage},
+    ))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Moved lead {args.lead_id} → stage {args.stage}")
+    return 0
+
+
+def cmd_tasks_list(args, cfg: dict) -> int:
+    params = {
+        "limit": args.limit, "projectId": args.project,
+        "assigneeId": args.assignee, "status": args.status,
+    }
+    items = _items(_api_call("GET", "/api/tasks", cfg=cfg, params=params))
+    if args.json:
+        print(json.dumps(items, indent=2))
+        return 0
+    for tk in items:
+        print(f"  [{tk.get('status', '?')}] {tk.get('title')}   {tk.get('id')}")
+    return 0
+
+
+def cmd_tasks_create(args, cfg: dict) -> int:
+    body = {"projectId": args.project, "title": args.title}
+    if args.priority:
+        body["priority"] = args.priority
+    if args.description:
+        body["description"] = args.description
+    data = _data(_api_call("POST", "/api/tasks", cfg=cfg, body=body))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Created task: {data.get('title')} ({data.get('id')})")
+    return 0
+
+
+def cmd_tasks_complete(args, cfg: dict) -> int:
+    # Valid task statuses: NotStarted / InProgress / Blocked / Review /
+    # Done / Cancelled. "Done" is the completion terminal; --status lets
+    # a caller set a different terminal (e.g. Cancelled).
+    data = _data(_api_call(
+        "PATCH", f"/api/tasks/{args.task_id}",
+        cfg=cfg, body={"status": args.status},
+    ))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Task {args.task_id} → {args.status}")
+    return 0
+
+
+def cmd_projects_list(args, cfg: dict) -> int:
+    params = {"limit": args.limit, "portfolioId": args.portfolio, "statusFilter": args.status}
+    items = _items(_api_call("GET", "/api/projects", cfg=cfg, params=params))
+    if args.json:
+        print(json.dumps(items, indent=2))
+        return 0
+    for pr in items:
+        code = f"  ({pr.get('code')})" if pr.get("code") else ""
+        print(f"  [{pr.get('status', '?')}] {pr.get('name')}{code}   {pr.get('id')}")
+    return 0
+
+
+def cmd_projects_create(args, cfg: dict) -> int:
+    body = {"name": args.name}
+    if args.code:
+        body["code"] = args.code
+    if args.description:
+        body["description"] = args.description
+    if args.portfolio:
+        body["portfolioId"] = args.portfolio
+    data = _data(_api_call("POST", "/api/projects", cfg=cfg, body=body))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Created project: {data.get('name')} ({data.get('id')})")
+    return 0
+
+
+def cmd_companies_list(args, cfg: dict) -> int:
+    params = {"limit": args.limit, "search": args.search}
+    items = _items(_api_call("GET", "/api/companies", cfg=cfg, params=params))
+    if args.json:
+        print(json.dumps(items, indent=2))
+        return 0
+    for co in items:
+        ind = f"  ({co.get('industry')})" if co.get("industry") else ""
+        print(f"  {co.get('name')}{ind}   {co.get('id')}")
+    return 0
+
+
+def cmd_companies_create(args, cfg: dict) -> int:
+    body = {"name": args.name}
+    for arg_name, wire in (("website", "website"), ("industry", "industry"),
+                           ("email", "email"), ("phone", "phone")):
+        val = getattr(args, arg_name)
+        if val:
+            body[wire] = val
+    data = _data(_api_call("POST", "/api/companies", cfg=cfg, body=body))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Created company: {data.get('name')} ({data.get('id')})")
+    return 0
+
+
+def cmd_custom_fields_list(args, cfg: dict) -> int:
+    params = {"entityType": args.entity}
+    items = _items(_api_call("GET", "/api/custom-fields", cfg=cfg, params=params))
+    if args.json:
+        print(json.dumps(items, indent=2))
+        return 0
+    for cf in items:
+        req = " *required" if cf.get("isRequired") else ""
+        print(f"  {cf.get('entityType')}.{cf.get('fieldKey')} "
+              f"({cf.get('fieldType')}) — {cf.get('label')}{req}   {cf.get('id')}")
+    return 0
+
+
+def cmd_saved_views_list(args, cfg: dict) -> int:
+    params = {"entityType": args.entity} if args.entity else None
+    items = _items(_api_call("GET", "/api/saved-views", cfg=cfg, params=params))
+    if args.json:
+        print(json.dumps(items, indent=2))
+        return 0
+    for sv in items:
+        print(f"  {sv.get('entityType')}: {sv.get('name')}   {sv.get('id')}")
+    return 0
+
+
+# ─── §31 batch 2b — members / task time-logs / saved-view create ───────
+#
+# Closes the remaining daily-driver gaps from §31.
+#
+# NOTE: `api-tokens` (list/mint/revoke) is deliberately NOT added. Those
+# endpoints (/api/me/api-tokens) refuse API-token callers by design — a
+# leaked bearer token must not be able to mint more tokens — and this CLI
+# authenticates with a bearer token, so the verbs would only ever 403.
+# Token management stays SPA-cookie-only. (Verified against
+# app/routers/api_tokens.py `_refuse_if_api_token_call` on all three routes.)
+
+
+def _self_user_id(cfg: dict) -> str | None:
+    """Resolve the signed-in user's own UUID via /api/me (for `leave`)."""
+    try:
+        me = _data(_api_call("GET", "/api/me", cfg=cfg))
+    except APIError:
+        return None
+    user = me.get("user") if isinstance(me, dict) else None
+    return (user or {}).get("id")
+
+
+def cmd_members_invite(args, cfg: dict) -> int:
+    if not cfg.get("active_mesh_id"):
+        print("No active mesh. Run: mesh meshes use NAME", file=sys.stderr)
+        return 2
+    mesh_id = cfg["active_mesh_id"]
+    uname = args.user.lstrip("@")
+    body: dict = {"username": uname}
+    if args.role:
+        body["role"] = args.role
+    data = _data(_api_call("POST", f"/api/meshes/{mesh_id}/invite", cfg=cfg, body=body))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    suffix = f" as {args.role}" if args.role else " (default invite role)"
+    print(f"Invited @{uname}{suffix}")
+    return 0
+
+
+def cmd_members_accept(args, cfg: dict) -> int:
+    """Accept (or --decline) a pending invitation to a mesh by its UUID.
+    The mesh isn't active yet, so this takes the mesh id explicitly —
+    list pending invites in the SPA or via /api/meshes/my-pending."""
+    action = "decline" if args.decline else "accept"
+    data = _data(_api_call(
+        "POST", f"/api/meshes/{args.mesh}/respond", cfg=cfg, body={"action": action}
+    ))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"{action.title()}ed invitation to mesh {args.mesh}")
+    return 0
+
+
+def cmd_members_set_role(args, cfg: dict) -> int:
+    if not cfg.get("active_mesh_id"):
+        print("No active mesh. Run: mesh meshes use NAME", file=sys.stderr)
+        return 2
+    mesh_id = cfg["active_mesh_id"]
+    user = _resolve_user(args.user, cfg)
+    if not user:
+        print(f"User {args.user!r} not found in active mesh.", file=sys.stderr)
+        return 1
+    data = _data(_api_call(
+        "POST", f"/api/meshes/{mesh_id}/set-role",
+        cfg=cfg, body={"userId": user["id"], "role": args.role},
+    ))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Set {args.user} → {args.role} in active mesh")
+    return 0
+
+
+def cmd_members_remove(args, cfg: dict) -> int:
+    if not cfg.get("active_mesh_id"):
+        print("No active mesh. Run: mesh meshes use NAME", file=sys.stderr)
+        return 2
+    mesh_id = cfg["active_mesh_id"]
+    user = _resolve_user(args.user, cfg)
+    if not user:
+        print(f"User {args.user!r} not found in active mesh.", file=sys.stderr)
+        return 1
+    data = _data(_api_call(
+        "POST", f"/api/meshes/{mesh_id}/remove", cfg=cfg, body={"userId": user["id"]}
+    ))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Removed {args.user} from active mesh")
+    return 0
+
+
+def cmd_members_leave(args, cfg: dict) -> int:
+    if not cfg.get("active_mesh_id"):
+        print("No active mesh. Run: mesh meshes use NAME", file=sys.stderr)
+        return 2
+    mesh_id = cfg["active_mesh_id"]
+    uid = _self_user_id(cfg)
+    if not uid:
+        print("Couldn't resolve your own user id from /api/me.", file=sys.stderr)
+        return 1
+    # §49: Account Managers can't leave a mesh attached to their own
+    # subscription — the server returns 403; surface its message.
+    data = _data(_api_call(
+        "POST", f"/api/meshes/{mesh_id}/remove", cfg=cfg, body={"userId": uid}
+    ))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Left mesh {mesh_id}")
+    return 0
+
+
+def cmd_tasks_log(args, cfg: dict) -> int:
+    """Log hours against a task (POST /api/task-time-logs). Date defaults
+    to today (UTC). Hours must be > 0 and ≤ 24."""
+    import datetime as _dt
+    log_date = args.date or _dt.datetime.now(_dt.timezone.utc).date().isoformat()
+    body: dict = {"taskId": args.task_id, "hours": args.hours, "loggedForDate": log_date}
+    if args.note:
+        body["note"] = args.note
+    data = _data(_api_call("POST", "/api/task-time-logs", cfg=cfg, body=body))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Logged {args.hours}h on task {args.task_id} for {log_date}")
+    return 0
+
+
+def cmd_saved_views_create(args, cfg: dict) -> int:
+    """Create a saved view. NOTE the create field is `module` (the entity
+    grouping the view belongs to, e.g. leads / contacts / tasks), NOT
+    `entityType` — verified against app/routers/saved_views.py SavedViewIn."""
+    body: dict = {"module": args.module, "name": args.name}
+    if args.filter:
+        try:
+            body["filterJson"] = json.loads(args.filter)
+        except json.JSONDecodeError as e:
+            print(f"--filter must be valid JSON: {e}", file=sys.stderr)
+            return 2
+    if args.shared:
+        body["isShared"] = True
+    data = _data(_api_call("POST", "/api/saved-views", cfg=cfg, body=body))
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Created saved view '{args.name}' for {args.module}  ({data.get('id')})")
+    return 0
+
+
 # ─── argparse plumbing ─────────────────────────────────────────────────
 
 
@@ -867,6 +1210,8 @@ def build_parser() -> argparse.ArgumentParser:
     chs = ch.add_subparsers(dest="chat_cmd", required=True)
     s = chs.add_parser("post", help="post a message in active mesh")
     s.add_argument("message")
+    s.add_argument("--reply-to", dest="reply_to",
+                   help="UUID of a message in this mesh to thread the reply under")
     s.set_defaults(func=cmd_chat_post)
     s = chs.add_parser("list", help="recent messages in active mesh")
     s.add_argument("--limit", type=int, default=20)
@@ -935,6 +1280,127 @@ def build_parser() -> argparse.ArgumentParser:
     s.add_argument("message", help="message body (markdown)")
     s.set_defaults(func=cmd_dm_send)
 
+    # leads  (§31 batch 2 — v0.3.0)
+    sl = sub.add_parser("leads", help="CRM leads")
+    sls = sl.add_subparsers(dest="leads_cmd", required=True)
+    s = sls.add_parser("list", help="list leads in active mesh")
+    s.add_argument("--limit", type=int, default=50)
+    s.add_argument("--pipeline", help="filter by pipeline UUID")
+    s.add_argument("--stage", help="filter by stage UUID")
+    s.add_argument("--company", help="filter by company UUID")
+    s.set_defaults(func=cmd_leads_list)
+    s = sls.add_parser("create", help="create a lead")
+    s.add_argument("--title", required=True)
+    s.add_argument("--pipeline", required=True, help="pipeline UUID")
+    s.add_argument("--stage", required=True, help="stage UUID")
+    s.add_argument("--value", type=float, help="value amount")
+    s.add_argument("--description")
+    s.set_defaults(func=cmd_leads_create)
+    s = sls.add_parser("move", help="move a lead to a different pipeline stage")
+    s.add_argument("lead_id", help="lead UUID")
+    s.add_argument("stage", help="target stage UUID")
+    s.set_defaults(func=cmd_leads_move)
+
+    # tasks  (§31 batch 2 — v0.3.0)
+    st = sub.add_parser("tasks", help="project tasks")
+    sts = st.add_subparsers(dest="tasks_cmd", required=True)
+    s = sts.add_parser("list", help="list tasks in active mesh")
+    s.add_argument("--limit", type=int, default=50)
+    s.add_argument("--project", help="filter by project UUID")
+    s.add_argument("--assignee", help="filter by assignee UUID")
+    s.add_argument("--status", help="filter by status (NotStarted/InProgress/Blocked/Review/Done/Cancelled)")
+    s.set_defaults(func=cmd_tasks_list)
+    s = sts.add_parser("create", help="create a task")
+    s.add_argument("--project", required=True, help="project UUID")
+    s.add_argument("--title", required=True)
+    s.add_argument("--priority", help="Low/Normal/High/Urgent")
+    s.add_argument("--description")
+    s.set_defaults(func=cmd_tasks_create)
+    s = sts.add_parser("complete", help="mark a task done (or another terminal status)")
+    s.add_argument("task_id", help="task UUID")
+    s.add_argument("--status", default="Done",
+                   help="terminal status to set (default Done; e.g. Cancelled)")
+    s.set_defaults(func=cmd_tasks_complete)
+    s = sts.add_parser("log", help="log hours against a task (time tracking)")
+    s.add_argument("task_id", help="task UUID")
+    s.add_argument("--hours", type=float, required=True, help="hours worked (0 < h <= 24)")
+    s.add_argument("--date", help="date worked (YYYY-MM-DD; default today UTC)")
+    s.add_argument("--note", help="optional note")
+    s.set_defaults(func=cmd_tasks_log)
+
+    # projects  (§31 batch 2 — v0.3.0)
+    sp = sub.add_parser("projects", help="task-container projects")
+    sps = sp.add_subparsers(dest="projects_cmd", required=True)
+    s = sps.add_parser("list", help="list projects in active mesh")
+    s.add_argument("--limit", type=int, default=50)
+    s.add_argument("--portfolio", help="filter by portfolio UUID")
+    s.add_argument("--status", help="filter by status (Planning/Active/OnHold/Complete/Cancelled)")
+    s.set_defaults(func=cmd_projects_list)
+    s = sps.add_parser("create", help="create a project")
+    s.add_argument("--name", required=True)
+    s.add_argument("--code", help="short project code")
+    s.add_argument("--description")
+    s.add_argument("--portfolio", help="portfolio UUID")
+    s.set_defaults(func=cmd_projects_create)
+
+    # companies  (§31 batch 2 — v0.3.0)
+    sco = sub.add_parser("companies", help="CRM companies")
+    scos = sco.add_subparsers(dest="companies_cmd", required=True)
+    s = scos.add_parser("list", help="list companies in active mesh")
+    s.add_argument("--search", help="search term")
+    s.add_argument("--limit", type=int, default=50)
+    s.set_defaults(func=cmd_companies_list)
+    s = scos.add_parser("create", help="create a company")
+    s.add_argument("--name", required=True)
+    s.add_argument("--website")
+    s.add_argument("--industry")
+    s.add_argument("--email")
+    s.add_argument("--phone")
+    s.set_defaults(func=cmd_companies_create)
+
+    # custom-fields (read)  (§31 batch 2 — v0.3.0)
+    scf = sub.add_parser("custom-fields", help="custom field definitions (read)")
+    scfs = scf.add_subparsers(dest="custom_fields_cmd", required=True)
+    s = scfs.add_parser("list", help="list custom field definitions")
+    s.add_argument("--entity", help="filter by entity type (contact/company/lead/...)")
+    s.set_defaults(func=cmd_custom_fields_list)
+
+    # saved-views (read)  (§31 batch 2 — v0.3.0)
+    ssv = sub.add_parser("saved-views", help="saved views (read)")
+    ssvs = ssv.add_subparsers(dest="saved_views_cmd", required=True)
+    s = ssvs.add_parser("list", help="list saved views")
+    s.add_argument("--entity", help="filter by entity type")
+    s.set_defaults(func=cmd_saved_views_list)
+    s = ssvs.add_parser("create", help="create a saved view")
+    s.add_argument("--module", required=True,
+                   help="entity grouping the view belongs to (leads/contacts/tasks/...)")
+    s.add_argument("--name", required=True, help="view name")
+    s.add_argument("--filter", help="filter as a JSON object string")
+    s.add_argument("--shared", action="store_true", help="share with the whole mesh")
+    s.set_defaults(func=cmd_saved_views_create)
+
+    # members  (§31 batch 2b)
+    smem = sub.add_parser("members", help="mesh membership (invite / accept / role / remove / leave)")
+    smems = smem.add_subparsers(dest="members_cmd", required=True)
+    s = smems.add_parser("invite", help="invite a user to the active mesh by username")
+    s.add_argument("user", help="username (with or without '@')")
+    s.add_argument("--role", choices=("admin", "member", "reader"),
+                   help="role (omit to use the mesh's default invite role)")
+    s.set_defaults(func=cmd_members_invite)
+    s = smems.add_parser("accept", help="accept (or --decline) a pending invitation by mesh UUID")
+    s.add_argument("mesh", help="mesh UUID you were invited to")
+    s.add_argument("--decline", action="store_true", help="decline instead of accept")
+    s.set_defaults(func=cmd_members_accept)
+    s = smems.add_parser("set-role", help="change a member's role in the active mesh")
+    s.add_argument("user", help="username, displayName, or UUID")
+    s.add_argument("role", choices=("member", "reader"), help="new role")
+    s.set_defaults(func=cmd_members_set_role)
+    s = smems.add_parser("remove", help="remove a member from the active mesh")
+    s.add_argument("user", help="username, displayName, or UUID")
+    s.set_defaults(func=cmd_members_remove)
+    s = smems.add_parser("leave", help="leave the active mesh (you)")
+    s.set_defaults(func=cmd_members_leave)
+
     # notifications
     s = sub.add_parser("notifications", help="recent notifications")
     s.set_defaults(func=cmd_notifications)

{meshbook_cli-0.2.0 → meshbook_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshbook-cli"
-version = "0.2.0"
+version = "0.4.0"
 description = "Small-model-friendly CLI for meshbook.org — built so non-humans of any size can run a CRM."
 readme = "README.md"
 license = "MIT"

meshbook_cli-0.4.0/tests/test_cli_smoke.py

@@ -0,0 +1,413 @@
+"""Smoke tests for meshbook-cli — argparse wiring + config persistence.
+
+Network-dependent commands aren't exercised here (the CLI calls
+meshbook.org directly via stdlib urllib). For end-to-end coverage,
+mint a token and run `mesh doctor` against a real or staging server.
+"""
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from mesh import cli
+
+
+def test_version_constant():
+    assert cli.VERSION
+    # Pep 440 sanity — three dot-separated numeric components.
+    parts = cli.VERSION.split(".")
+    assert len(parts) >= 2
+    assert parts[0].isdigit()
+
+
+def test_help_runs(capsys):
+    """`mesh --help` must exit 0 and mention the top-level commands."""
+    parser = cli.build_parser()
+    with pytest.raises(SystemExit) as exc:
+        parser.parse_args(["--help"])
+    assert exc.value.code == 0
+    out = capsys.readouterr().out
+    for cmd in ("login", "logout", "whoami", "doctor",
+                "meshes", "contacts", "chat", "channels", "dm",
+                "leads", "tasks", "projects", "companies",
+                "custom-fields", "saved-views", "notifications"):
+        assert cmd in out
+
+
+def test_chat_subcommands_present(capsys):
+    parser = cli.build_parser()
+    with pytest.raises(SystemExit) as exc:
+        parser.parse_args(["chat", "--help"])
+    assert exc.value.code == 0
+    out = capsys.readouterr().out
+    for sub in ("post", "list", "attach", "react", "unreact"):
+        assert sub in out
+
+
+def test_channels_subcommands_present(capsys):
+    """§31 sweep — channel verbs landed in v0.2.0."""
+    parser = cli.build_parser()
+    with pytest.raises(SystemExit) as exc:
+        parser.parse_args(["channels", "--help"])
+    assert exc.value.code == 0
+    out = capsys.readouterr().out
+    for sub in ("list", "read", "post", "reply", "create"):
+        assert sub in out
+
+
+def test_dm_subcommands_present(capsys):
+    """§31 sweep — DM verbs landed in v0.2.0."""
+    parser = cli.build_parser()
+    with pytest.raises(SystemExit) as exc:
+        parser.parse_args(["dm", "--help"])
+    assert exc.value.code == 0
+    out = capsys.readouterr().out
+    for sub in ("list", "read", "send"):
+        assert sub in out
+
+
+def test_channels_create_broadcast_severity_required_via_default(capsys, tmp_path, monkeypatch):
+    """`channels create foo --type broadcast` should default broadcastSeverity
+    to 'fyi' on the wire — verifies the body shape we send to the server."""
+    captured = {}
+
+    def fake_api_call(method, path, *, cfg, body=None, **kw):
+        captured["method"] = method
+        captured["path"] = path
+        captured["body"] = body
+        return {"data": {"id": "new-id", "name": "test-bc", "channelType": "broadcast",
+                         "broadcastSeverity": "fyi"}}
+
+    monkeypatch.setattr(cli, "_api_call", fake_api_call)
+    monkeypatch.setattr(cli, "CONFIG_DIR", tmp_path / ".meshbook")
+    monkeypatch.setattr(cli, "CONFIG_PATH", tmp_path / ".meshbook" / "config")
+
+    args = type("A", (), {
+        "name": "#test-bc", "topic": None, "type": "broadcast",
+        "severity": None, "private": False, "json": False,
+    })()
+    rc = cli.cmd_channels_create(args, {"active_mesh_id": "mesh-1"})
+    assert rc == 0
+    assert captured["method"] == "POST"
+    assert captured["path"] == "/api/meshes/mesh-1/channels"
+    assert captured["body"]["name"] == "test-bc"           # # stripped
+    assert captured["body"]["channelType"] == "broadcast"
+    assert captured["body"]["broadcastSeverity"] == "fyi"  # default applied
+
+
+def test_resolve_channel_strips_hash(monkeypatch):
+    """Channel resolution must strip a leading '#' (humans type `#bugs`,
+    the underlying name is just `bugs`)."""
+    monkeypatch.setattr(cli, "_list_channels_raw", lambda cfg, mesh_id=None: [
+        {"id": "ch-1", "name": "bugs"},
+        {"id": "ch-2", "name": "general"},
+    ])
+    out = cli._resolve_channel("#bugs", {"active_mesh_id": "m"})
+    assert out and out["id"] == "ch-1"
+    # Also case-insensitive
+    out = cli._resolve_channel("BUGS", {"active_mesh_id": "m"})
+    assert out and out["id"] == "ch-1"
+    # Missing name
+    assert cli._resolve_channel("nope", {"active_mesh_id": "m"}) is None
+
+
+# ─── §31 batch 2 (v0.3.0) — CRM verbs ──────────────────────────────────
+
+
+@pytest.mark.parametrize("group,subs", [
+    ("leads", ("list", "create", "move")),
+    ("tasks", ("list", "create", "complete")),
+    ("projects", ("list", "create")),
+    ("companies", ("list", "create")),
+    ("custom-fields", ("list",)),
+    ("saved-views", ("list",)),
+])
+def test_batch2_subcommands_present(capsys, group, subs):
+    parser = cli.build_parser()
+    with pytest.raises(SystemExit) as exc:
+        parser.parse_args([group, "--help"])
+    assert exc.value.code == 0
+    out = capsys.readouterr().out
+    for sub in subs:
+        assert sub in out, f"{group} missing subcommand {sub}"
+
+
+def test_items_envelope_shapes():
+    """_items must normalise bare-list, {data:[...]}, and
+    {data:{items:[...]}} into a plain list."""
+    assert cli._items([1, 2, 3]) == [1, 2, 3]
+    assert cli._items({"data": [1, 2]}) == [1, 2]
+    assert cli._items({"data": {"items": [9], "total": 1}}) == [9]
+    assert cli._items({"data": None}) == []
+    assert cli._items(None) == []
+
+
+def test_leads_create_wire_shape(monkeypatch):
+    """Lead create must send camelCase pipelineId/stageId + title."""
+    captured = {}
+
+    def fake_api_call(method, path, *, cfg, body=None, **kw):
+        captured.update(method=method, path=path, body=body)
+        return {"data": {"id": "lead-1", "title": "Big deal"}}
+
+    monkeypatch.setattr(cli, "_api_call", fake_api_call)
+    args = type("A", (), {
+        "title": "Big deal", "pipeline": "pid", "stage": "sid",
+        "value": 1000.0, "description": None, "json": False,
+    })()
+    rc = cli.cmd_leads_create(args, {"active_mesh_id": "m"})
+    assert rc == 0
+    assert captured["method"] == "POST"
+    assert captured["path"] == "/api/leads"
+    assert captured["body"] == {
+        "title": "Big deal", "pipelineId": "pid", "stageId": "sid",
+        "valueAmount": 1000.0,
+    }
+
+
+def test_tasks_complete_wire_shape(monkeypatch):
+    """tasks complete defaults to PATCH status=Done on /api/tasks/{id}."""
+    captured = {}
+
+    def fake_api_call(method, path, *, cfg, body=None, **kw):
+        captured.update(method=method, path=path, body=body)
+        return {"data": {"id": "t-1", "status": "Done"}}
+
+    monkeypatch.setattr(cli, "_api_call", fake_api_call)
+    args = type("A", (), {"task_id": "t-1", "status": "Done", "json": False})()
+    rc = cli.cmd_tasks_complete(args, {"active_mesh_id": "m"})
+    assert rc == 0
+    assert captured["method"] == "PATCH"
+    assert captured["path"] == "/api/tasks/t-1"
+    assert captured["body"] == {"status": "Done"}
+
+
+def test_leads_move_wire_shape(monkeypatch):
+    captured = {}
+
+    def fake_api_call(method, path, *, cfg, body=None, **kw):
+        captured.update(method=method, path=path, body=body)
+        return {"data": {"id": "lead-1"}}
+
+    monkeypatch.setattr(cli, "_api_call", fake_api_call)
+    args = type("A", (), {"lead_id": "lead-1", "stage": "stage-2", "json": False})()
+    rc = cli.cmd_leads_move(args, {"active_mesh_id": "m"})
+    assert rc == 0
+    assert captured["path"] == "/api/leads/lead-1/move-stage"
+    assert captured["body"] == {"stageId": "stage-2"}
+
+
+# ─── §31 batch 2b — members / task time-logs / saved-view create ───────
+
+
+def test_help_includes_members(capsys):
+    parser = cli.build_parser()
+    with pytest.raises(SystemExit):
+        parser.parse_args(["--help"])
+    assert "members" in capsys.readouterr().out
+
+
+@pytest.mark.parametrize("group,subs", [
+    ("members", ("invite", "accept", "set-role", "remove", "leave")),
+    ("tasks", ("log",)),
+    ("saved-views", ("create",)),
+])
+def test_batch2b_subcommands_present(capsys, group, subs):
+    parser = cli.build_parser()
+    with pytest.raises(SystemExit) as exc:
+        parser.parse_args([group, "--help"])
+    assert exc.value.code == 0
+    out = capsys.readouterr().out
+    for sub in subs:
+        assert sub in out, f"{group} missing subcommand {sub}"
+
+
+def test_members_invite_wire_shape(monkeypatch):
+    captured = {}
+
+    def fake_api_call(method, path, *, cfg, body=None, **kw):
+        captured.update(method=method, path=path, body=body)
+        return {"data": {"invited": True}}
+
+    monkeypatch.setattr(cli, "_api_call", fake_api_call)
+    args = type("A", (), {"user": "@rook", "role": "member", "json": False})()
+    rc = cli.cmd_members_invite(args, {"active_mesh_id": "m1"})
+    assert rc == 0
+    assert captured["method"] == "POST"
+    assert captured["path"] == "/api/meshes/m1/invite"
+    assert captured["body"] == {"username": "rook", "role": "member"}
+
+
+def test_members_invite_default_role_omitted(monkeypatch):
+    captured = {}
+    monkeypatch.setattr(cli, "_api_call",
+                        lambda m, p, *, cfg, body=None, **kw: captured.update(body=body) or {"data": {}})
+    args = type("A", (), {"user": "rook", "role": None, "json": False})()
+    cli.cmd_members_invite(args, {"active_mesh_id": "m1"})
+    assert captured["body"] == {"username": "rook"}  # no role key when default
+
+
+def test_members_set_role_wire_shape(monkeypatch):
+    captured = {}
+
+    def fake_api_call(method, path, *, cfg, body=None, **kw):
+        captured.update(method=method, path=path, body=body)
+        return {"data": {}}
+
+    monkeypatch.setattr(cli, "_api_call", fake_api_call)
+    monkeypatch.setattr(cli, "_resolve_user", lambda u, cfg: {"id": "u-9"})
+    args = type("A", (), {"user": "rook", "role": "reader", "json": False})()
+    rc = cli.cmd_members_set_role(args, {"active_mesh_id": "m1"})
+    assert rc == 0
+    assert captured["path"] == "/api/meshes/m1/set-role"
+    assert captured["body"] == {"userId": "u-9", "role": "reader"}
+
+
+def test_members_accept_wire_shape(monkeypatch):
+    captured = {}
+    monkeypatch.setattr(cli, "_api_call",
+                        lambda m, p, *, cfg, body=None, **kw: captured.update(path=p, body=body) or {"data": {}})
+    args = type("A", (), {"mesh": "mesh-7", "decline": False, "json": False})()
+    cli.cmd_members_accept(args, {})
+    assert captured["path"] == "/api/meshes/mesh-7/respond"
+    assert captured["body"] == {"action": "accept"}
+
+
+def test_tasks_log_wire_shape_defaults_today(monkeypatch):
+    captured = {}
+    monkeypatch.setattr(cli, "_api_call",
+                        lambda m, p, *, cfg, body=None, **kw: captured.update(method=m, path=p, body=body) or {"data": {}})
+    args = type("A", (), {"task_id": "t-1", "hours": 2.5, "date": None, "note": None, "json": False})()
+    rc = cli.cmd_tasks_log(args, {"active_mesh_id": "m1"})
+    assert rc == 0
+    assert captured["method"] == "POST"
+    assert captured["path"] == "/api/task-time-logs"
+    assert captured["body"]["taskId"] == "t-1"
+    assert captured["body"]["hours"] == 2.5
+    # date defaulted to an ISO YYYY-MM-DD string
+    assert len(captured["body"]["loggedForDate"]) == 10 and captured["body"]["loggedForDate"].count("-") == 2
+    assert "note" not in captured["body"]
+
+
+def test_saved_views_create_uses_module_field(monkeypatch):
+    """Regression guard: create body uses `module`, NOT `entityType`
+    (verified against SavedViewIn). A wrong key would 422 server-side."""
+    captured = {}
+    monkeypatch.setattr(cli, "_api_call",
+                        lambda m, p, *, cfg, body=None, **kw: captured.update(path=p, body=body) or {"data": {"id": "sv-1"}})
+    args = type("A", (), {"module": "leads", "name": "Hot", "filter": '{"stageId":"x"}', "shared": True, "json": False})()
+    rc = cli.cmd_saved_views_create(args, {"active_mesh_id": "m1"})
+    assert rc == 0
+    assert captured["path"] == "/api/saved-views"
+    assert captured["body"] == {"module": "leads", "name": "Hot",
+                                "filterJson": {"stageId": "x"}, "isShared": True}
+
+
+def test_saved_views_create_bad_filter_json(monkeypatch):
+    monkeypatch.setattr(cli, "_api_call", lambda *a, **k: {"data": {}})
+    args = type("A", (), {"module": "leads", "name": "X", "filter": "{not json", "shared": False, "json": False})()
+    assert cli.cmd_saved_views_create(args, {}) == 2
+
+
+def test_chat_post_reply_to_threads(monkeypatch):
+    captured = {}
+    monkeypatch.setattr(cli, "_api_call",
+                        lambda m, p, *, cfg, body=None, **kw: captured.update(path=p, body=body) or {"data": {"id": "msg-2"}})
+    args = type("A", (), {"message": "re: that", "reply_to": "msg-1", "json": False})()
+    rc = cli.cmd_chat_post(args, {"active_mesh_id": "m1"})
+    assert rc == 0
+    assert captured["path"] == "/api/entities/mesh/m1/chat"
+    assert captured["body"] == {"bodyMd": "re: that", "parentMessageId": "msg-1"}
+
+
+def test_config_round_trip(tmp_path, monkeypatch):
+    """Config writes + reads cleanly through load/save/reset."""
+    monkeypatch.setattr(cli, "CONFIG_DIR", tmp_path / ".meshbook")
+    monkeypatch.setattr(cli, "CONFIG_PATH", tmp_path / ".meshbook" / "config")
+
+    assert cli.load_config() == {}
+
+    payload = {"token": "mb_token_test", "active_mesh_id": "abc-123"}
+    cli.save_config(payload)
+    assert cli.CONFIG_PATH.exists()
+
+    # POSIX permission tightening — only assert on platforms that have
+    # `os.chmod` semantics matching ours. Windows masks 0o600 to 0o666;
+    # the call is harmless but the bits differ.
+    if os.name == "posix":
+        assert (cli.CONFIG_PATH.stat().st_mode & 0o777) == 0o600
+
+    loaded = cli.load_config()
+    assert loaded["token"] == "mb_token_test"
+    assert loaded["active_mesh_id"] == "abc-123"
+
+    cli.reset_config()
+    assert cli.load_config() == {}
+
+
+def test_corrupt_config_returns_empty(tmp_path, monkeypatch):
+    """A garbled config file shouldn't crash the CLI."""
+    monkeypatch.setattr(cli, "CONFIG_DIR", tmp_path / ".meshbook")
+    monkeypatch.setattr(cli, "CONFIG_PATH", tmp_path / ".meshbook" / "config")
+
+    cli.CONFIG_DIR.mkdir()
+    cli.CONFIG_PATH.write_text("{ not valid json")
+    assert cli.load_config() == {}
+
+
+def test_invalid_token_does_not_persist(tmp_path, monkeypatch):
+    """Bug Rook flagged 2026-05-10 — an invalid `--token` would write
+    to disk before /api/me verification. The fix: verify against an
+    in-memory test_cfg first, only persist on success."""
+    monkeypatch.setattr(cli, "CONFIG_DIR", tmp_path / ".meshbook")
+    monkeypatch.setattr(cli, "CONFIG_PATH", tmp_path / ".meshbook" / "config")
+
+    # Stub out _api_call so it returns the "authenticated=false" shape
+    # /api/me actually emits for an invalid bearer.
+    def fake_api_call(method, path, *, cfg, **kw):
+        return {"data": {"authenticated": False}}
+
+    monkeypatch.setattr(cli, "_api_call", fake_api_call)
+
+    args = type("A", (), {"token": "mb_token_garbage", "base": None})()
+    rc = cli.cmd_login(args, {})
+    assert rc == 1, "cmd_login should fail on authenticated=false response"
+    assert not cli.CONFIG_PATH.exists(), \
+        "invalid token must NOT have been persisted to config"
+
+
+def test_xdg_config_home_honoured(monkeypatch, tmp_path):
+    """Defensive — if XDG_CONFIG_HOME is set AND ~/.meshbook doesn't
+    exist, the CLI should write under XDG. Legacy ~/.meshbook stays
+    canonical for upgrade safety."""
+    fake_home = tmp_path / "home"
+    fake_xdg = tmp_path / "xdg"
+    fake_home.mkdir()
+    monkeypatch.setattr(cli.Path, "home", classmethod(lambda cls: fake_home))
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(fake_xdg))
+    monkeypatch.delenv("MESHBOOK_CONFIG_DIR", raising=False)
+    resolved = cli._resolve_config_dir()
+    # Legacy doesn't exist → XDG wins
+    assert resolved == fake_xdg / "meshbook", resolved
+
+
+def test_legacy_config_dir_takes_precedence(monkeypatch, tmp_path):
+    """If `~/.meshbook` already exists from a prior install, keep
+    using it — don't silently migrate the user's token away."""
+    fake_home = tmp_path / "home"
+    legacy = fake_home / ".meshbook"
+    legacy.mkdir(parents=True)
+    monkeypatch.setattr(cli.Path, "home", classmethod(lambda cls: fake_home))
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg"))
+    monkeypatch.delenv("MESHBOOK_CONFIG_DIR", raising=False)
+    assert cli._resolve_config_dir() == legacy
+
+
+def test_explicit_meshbook_config_dir_wins(monkeypatch, tmp_path):
+    """`MESHBOOK_CONFIG_DIR` overrides everything (Pi users w/
+    read-only home directories pin to a writable mount)."""
+    explicit = tmp_path / "explicit"
+    monkeypatch.setenv("MESHBOOK_CONFIG_DIR", str(explicit))
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg"))
+    assert cli._resolve_config_dir() == explicit

meshbook_cli-0.2.0/tests/test_cli_smoke.py

@@ -1,203 +0,0 @@
-"""Smoke tests for meshbook-cli — argparse wiring + config persistence.
-
-Network-dependent commands aren't exercised here (the CLI calls
-meshbook.org directly via stdlib urllib). For end-to-end coverage,
-mint a token and run `mesh doctor` against a real or staging server.
-"""
-from __future__ import annotations
-
-import os
-
-import pytest
-
-from mesh import cli
-
-
-def test_version_constant():
-    assert cli.VERSION
-    # Pep 440 sanity — three dot-separated numeric components.
-    parts = cli.VERSION.split(".")
-    assert len(parts) >= 2
-    assert parts[0].isdigit()
-
-
-def test_help_runs(capsys):
-    """`mesh --help` must exit 0 and mention the top-level commands."""
-    parser = cli.build_parser()
-    with pytest.raises(SystemExit) as exc:
-        parser.parse_args(["--help"])
-    assert exc.value.code == 0
-    out = capsys.readouterr().out
-    for cmd in ("login", "logout", "whoami", "doctor",
-                "meshes", "contacts", "chat", "channels", "dm",
-                "notifications"):
-        assert cmd in out
-
-
-def test_chat_subcommands_present(capsys):
-    parser = cli.build_parser()
-    with pytest.raises(SystemExit) as exc:
-        parser.parse_args(["chat", "--help"])
-    assert exc.value.code == 0
-    out = capsys.readouterr().out
-    for sub in ("post", "list", "attach", "react", "unreact"):
-        assert sub in out
-
-
-def test_channels_subcommands_present(capsys):
-    """§31 sweep — channel verbs landed in v0.2.0."""
-    parser = cli.build_parser()
-    with pytest.raises(SystemExit) as exc:
-        parser.parse_args(["channels", "--help"])
-    assert exc.value.code == 0
-    out = capsys.readouterr().out
-    for sub in ("list", "read", "post", "reply", "create"):
-        assert sub in out
-
-
-def test_dm_subcommands_present(capsys):
-    """§31 sweep — DM verbs landed in v0.2.0."""
-    parser = cli.build_parser()
-    with pytest.raises(SystemExit) as exc:
-        parser.parse_args(["dm", "--help"])
-    assert exc.value.code == 0
-    out = capsys.readouterr().out
-    for sub in ("list", "read", "send"):
-        assert sub in out
-
-
-def test_channels_create_broadcast_severity_required_via_default(capsys, tmp_path, monkeypatch):
-    """`channels create foo --type broadcast` should default broadcastSeverity
-    to 'fyi' on the wire — verifies the body shape we send to the server."""
-    captured = {}
-
-    def fake_api_call(method, path, *, cfg, body=None, **kw):
-        captured["method"] = method
-        captured["path"] = path
-        captured["body"] = body
-        return {"data": {"id": "new-id", "name": "test-bc", "channelType": "broadcast",
-                         "broadcastSeverity": "fyi"}}
-
-    monkeypatch.setattr(cli, "_api_call", fake_api_call)
-    monkeypatch.setattr(cli, "CONFIG_DIR", tmp_path / ".meshbook")
-    monkeypatch.setattr(cli, "CONFIG_PATH", tmp_path / ".meshbook" / "config")
-
-    args = type("A", (), {
-        "name": "#test-bc", "topic": None, "type": "broadcast",
-        "severity": None, "private": False, "json": False,
-    })()
-    rc = cli.cmd_channels_create(args, {"active_mesh_id": "mesh-1"})
-    assert rc == 0
-    assert captured["method"] == "POST"
-    assert captured["path"] == "/api/meshes/mesh-1/channels"
-    assert captured["body"]["name"] == "test-bc"           # # stripped
-    assert captured["body"]["channelType"] == "broadcast"
-    assert captured["body"]["broadcastSeverity"] == "fyi"  # default applied
-
-
-def test_resolve_channel_strips_hash(monkeypatch):
-    """Channel resolution must strip a leading '#' (humans type `#bugs`,
-    the underlying name is just `bugs`)."""
-    monkeypatch.setattr(cli, "_list_channels_raw", lambda cfg, mesh_id=None: [
-        {"id": "ch-1", "name": "bugs"},
-        {"id": "ch-2", "name": "general"},
-    ])
-    out = cli._resolve_channel("#bugs", {"active_mesh_id": "m"})
-    assert out and out["id"] == "ch-1"
-    # Also case-insensitive
-    out = cli._resolve_channel("BUGS", {"active_mesh_id": "m"})
-    assert out and out["id"] == "ch-1"
-    # Missing name
-    assert cli._resolve_channel("nope", {"active_mesh_id": "m"}) is None
-
-
-def test_config_round_trip(tmp_path, monkeypatch):
-    """Config writes + reads cleanly through load/save/reset."""
-    monkeypatch.setattr(cli, "CONFIG_DIR", tmp_path / ".meshbook")
-    monkeypatch.setattr(cli, "CONFIG_PATH", tmp_path / ".meshbook" / "config")
-
-    assert cli.load_config() == {}
-
-    payload = {"token": "mb_token_test", "active_mesh_id": "abc-123"}
-    cli.save_config(payload)
-    assert cli.CONFIG_PATH.exists()
-
-    # POSIX permission tightening — only assert on platforms that have
-    # `os.chmod` semantics matching ours. Windows masks 0o600 to 0o666;
-    # the call is harmless but the bits differ.
-    if os.name == "posix":
-        assert (cli.CONFIG_PATH.stat().st_mode & 0o777) == 0o600
-
-    loaded = cli.load_config()
-    assert loaded["token"] == "mb_token_test"
-    assert loaded["active_mesh_id"] == "abc-123"
-
-    cli.reset_config()
-    assert cli.load_config() == {}
-
-
-def test_corrupt_config_returns_empty(tmp_path, monkeypatch):
-    """A garbled config file shouldn't crash the CLI."""
-    monkeypatch.setattr(cli, "CONFIG_DIR", tmp_path / ".meshbook")
-    monkeypatch.setattr(cli, "CONFIG_PATH", tmp_path / ".meshbook" / "config")
-
-    cli.CONFIG_DIR.mkdir()
-    cli.CONFIG_PATH.write_text("{ not valid json")
-    assert cli.load_config() == {}
-
-
-def test_invalid_token_does_not_persist(tmp_path, monkeypatch):
-    """Bug Rook flagged 2026-05-10 — an invalid `--token` would write
-    to disk before /api/me verification. The fix: verify against an
-    in-memory test_cfg first, only persist on success."""
-    monkeypatch.setattr(cli, "CONFIG_DIR", tmp_path / ".meshbook")
-    monkeypatch.setattr(cli, "CONFIG_PATH", tmp_path / ".meshbook" / "config")
-
-    # Stub out _api_call so it returns the "authenticated=false" shape
-    # /api/me actually emits for an invalid bearer.
-    def fake_api_call(method, path, *, cfg, **kw):
-        return {"data": {"authenticated": False}}
-
-    monkeypatch.setattr(cli, "_api_call", fake_api_call)
-
-    args = type("A", (), {"token": "mb_token_garbage", "base": None})()
-    rc = cli.cmd_login(args, {})
-    assert rc == 1, "cmd_login should fail on authenticated=false response"
-    assert not cli.CONFIG_PATH.exists(), \
-        "invalid token must NOT have been persisted to config"
-
-
-def test_xdg_config_home_honoured(monkeypatch, tmp_path):
-    """Defensive — if XDG_CONFIG_HOME is set AND ~/.meshbook doesn't
-    exist, the CLI should write under XDG. Legacy ~/.meshbook stays
-    canonical for upgrade safety."""
-    fake_home = tmp_path / "home"
-    fake_xdg = tmp_path / "xdg"
-    fake_home.mkdir()
-    monkeypatch.setattr(cli.Path, "home", classmethod(lambda cls: fake_home))
-    monkeypatch.setenv("XDG_CONFIG_HOME", str(fake_xdg))
-    monkeypatch.delenv("MESHBOOK_CONFIG_DIR", raising=False)
-    resolved = cli._resolve_config_dir()
-    # Legacy doesn't exist → XDG wins
-    assert resolved == fake_xdg / "meshbook", resolved
-
-
-def test_legacy_config_dir_takes_precedence(monkeypatch, tmp_path):
-    """If `~/.meshbook` already exists from a prior install, keep
-    using it — don't silently migrate the user's token away."""
-    fake_home = tmp_path / "home"
-    legacy = fake_home / ".meshbook"
-    legacy.mkdir(parents=True)
-    monkeypatch.setattr(cli.Path, "home", classmethod(lambda cls: fake_home))
-    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg"))
-    monkeypatch.delenv("MESHBOOK_CONFIG_DIR", raising=False)
-    assert cli._resolve_config_dir() == legacy
-
-
-def test_explicit_meshbook_config_dir_wins(monkeypatch, tmp_path):
-    """`MESHBOOK_CONFIG_DIR` overrides everything (Pi users w/
-    read-only home directories pin to a writable mount)."""
-    explicit = tmp_path / "explicit"
-    monkeypatch.setenv("MESHBOOK_CONFIG_DIR", str(explicit))
-    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg"))
-    assert cli._resolve_config_dir() == explicit