magic-campus-sdk 0.1.0__py3-none-any.whl

magic_campus_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: magic-campus-sdk
+Version: 0.1.0
+Summary: MagicCampus platform SDK and CLI with bundled IM transport support.
+Author: MagicCampus Contributors
+License-Expression: AGPL-3.0-or-later
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: protobuf<7,>=6.32.0
+Requires-Dist: websocket-client<2,>=1.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+
+# magic-campus-sdk
+
+Python SDK and CLI for MagicCampus platform integrations. IM remains a supported domain, and this repository keeps the bundled OpenIM transport inside `magiccampus_sdk`.
+
+This project removes direct user-facing dependency on OpenIM token and endpoint configuration. You only configure:
+
+- `apiurl`
+- `apikey`
+- `platform`
+
+At runtime, IM-backed flows call:
+
+`GET /api/v1/accounts/imToken?platform=<PLATFORM>`
+
+and uses the response fields:
+
+- `userId`
+- `imToken`
+- `wsApi`
+- `httpApi`
+
+## Install locally
+
+```bash
+uv sync
+```
+
+This repository vendors only the OpenIM transport pieces that `magiccampus_sdk` actually uses, and layers platform-facing SDK / CLI commands on top.
+
+IM-specific low-level internals, models, and protobufs now live under `magiccampus_sdk.im`.
+
+## CLI quick start
+
+```bash
+magic-campus --help
+magic-campus config init --apiurl https://api-test.pearlapi.com --apikey "$MAGICCAMPUS_APIKEY" --platform IOS --default true
+magic-campus auth status --format pretty
+magic-campus im notify send --to user:10134002 --text "hello"
+magic-campus user get --id 10134002 --format pretty
+```
+
+`magic-campus config init` also supports an interactive TTY flow when you omit auth flags.
+
+`im notify send` sends over MagicCampus HTTP `POST /agent/v1/im/sendMessage`. `im notify history` still relies on the websocket transport and local sync database.
+
+Legacy compatibility commands remain available:
+
+```bash
+magic-campus notify +send --to user:10134002 --text "hello"
+magic-campus notify +history --to user:10134002
+```
+
+CLI config is stored at:
+
+`~/.mushroom_agent/auth/magiccampus-im-sdk.json`
+
+Supported commands:
+
+- `config init|list|use|remove`
+- `auth status`
+- `im notify send`
+- `im notify history`
+- `user get`
+- `feed list`
+- `notify +send` (compat)
+- `notify +history` (compat)
+
+## Python SDK quick start
+
+```python
+from magiccampus_sdk import MagicCampusClient, MagicCampusClientConfig
+
+client = MagicCampusClient(
+    MagicCampusClientConfig(
+        apiurl="https://api-test.pearlapi.com",
+        apikey="YOUR_API_KEY",
+        platform="IOS",
+        data_dir="./magiccampus_data",
+    )
+)
+
+user = client.user.get("10134002")
+print(user.nickname)
+print(user.avatar_url)
+```
+
+## Python websocket quick start
+
+```python
+from magiccampus_sdk import MagicCampusWSSDK, MagicCampusWSConfig
+
+sdk = MagicCampusWSSDK(
+    MagicCampusWSConfig(
+        apiurl="https://api-test.pearlapi.com",
+        apikey="YOUR_API_KEY",
+        platform="IOS",
+        data_dir="./magiccampus_data",
+    )
+)
+
+sdk.login()
+sdk.start()
+sdk.send_text("hello", recv_id="10134002")
+```
+
+Runnable examples live in [magiccampus_sdk/example.py](magiccampus_sdk/example.py) and [magiccampus_sdk/example_ws.py](magiccampus_sdk/example_ws.py).
+
+## CLI smoke script
+
+An executable smoke helper lives at [scripts/smoke_cli.py](scripts/smoke_cli.py).
+
+Offline-safe mode only exercises config persistence and notify dry-run:
+
+```bash
+uv run python scripts/smoke_cli.py
+```
+
+This mode does not require a real API key. It uses a placeholder key by default and avoids any live auth call.
+
+## Real network mode
+
+To run the live auth probe, provide a real API key and enable `--live`:
+
+```bash
+export MAGICCAMPUS_APIURL=https://api-test.pearlapi.com
+export MAGICCAMPUS_APIKEY='your real api key'
+export MAGICCAMPUS_PLATFORM=IOS
+uv run python scripts/smoke_cli.py --live
+```
+
+Optional variables:
+
+- `MAGICCAMPUS_SMOKE_TARGET`: target used by dry-run and optional live send, default `user:smoke-target`
+- `MAGICCAMPUS_PLATFORM`: defaults to `IOS`
+
+If you also want to send a real text message, set a real target and pass `--live-send`:
+
+```bash
+export MAGICCAMPUS_SMOKE_TARGET='user:10134002'
+uv run python scripts/smoke_cli.py --live --live-send --text 'hello from smoke script'
+```
+
+`--live-send` performs a real outbound send, so use it only with a valid target and credentials.
+
+## Notes
+
+- `apiurl` can point to any MagicCampus API base URL; IM-backed flows append `/api/v1/accounts/imToken`
+- `client.user.get(...)` calls `GET /api/v1/accounts/getUserInfo` with `apiurl` and `apikey` directly
+- `platform` defaults to `IOS`
+- low-level IM send / receive behavior comes from the bundled transport modules inside `magiccampus_sdk`
+- the wrapper does not persist raw OpenIM credentials in CLI config

magic_campus_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,50 @@
+magiccampus_cli/__init__.py,sha256=Pru0BlFBASFCFo7McHdohtKkUtgMPDwbGfyUZlE2_Vw,21
+magiccampus_cli/__main__.py,sha256=8M3vaTgigNUzQIxx-_rJFzfrAea2Oh_bU176_Fg1ywI,134
+magiccampus_cli/accounts.py,sha256=UfxnKzWca3lJMTxC2AVe_k8J73uF2Np9rJcU5AE5OD8,4521
+magiccampus_cli/cli.py,sha256=Cyp1mg_SuX59MUHLCGeZZiR-mZgxVwlEr07udS3eLPQ,4648
+magiccampus_cli/client.py,sha256=4cJaWhGDXDu0sDhmIQvnXDzSZjPatLGKsekBh2oCB6w,3092
+magiccampus_cli/config_store.py,sha256=_LUbyo7M7g6gh1dNzynwERxTMYAhm7z9EqGMf32j8GI,1693
+magiccampus_cli/http_send.py,sha256=feP3R7a2IpR4r-FN1HiHt_7ZYP1nRnA2PlS5X7k8JGc,20050
+magiccampus_cli/notify.py,sha256=9eUpHyNolnN9_XY6oY1eNTgRtzQGBAwRZkcSjGVrR-Y,13118
+magiccampus_cli/output.py,sha256=ljIi6sC10D9Mu1DTIJhrXO2pLSH5aQO6fdjgeoFnwU8,3058
+magiccampus_cli/prompts.py,sha256=gTNnSSWlXiFNEeAQjHtp2vhCUt88yp3QcX7gQD3ZX2Y,1648
+magiccampus_cli/targets.py,sha256=1Vi8hEXDuAuXDCHi6SNOY2A2hNW9NIbjNukAKatk6s4,885
+magiccampus_cli/utils.py,sha256=poyTOYbAD1h-4wmJPCCA_BzLp4Xh79kQXEGwh65_HDk,1683
+magiccampus_cli/commands/auth.py,sha256=daxjFUvN5I_l-zC-YvbXWRavO9AdleIZpeQZT68ua8s,927
+magiccampus_cli/commands/config.py,sha256=yUx0sq7zfcVv6OzeJaDgrz1_OLgajMGyHSFzBXZGYHM,3994
+magiccampus_cli/commands/feed.py,sha256=keAXbZjY7Y9kVwT2Wz47YGU8565G4QIak6tJi-nEVi4,786
+magiccampus_cli/commands/im.py,sha256=d5MF3OAdIlGbaYlXqVBMIjFTVHze-cXFIqBxJ5v6gu8,637
+magiccampus_cli/commands/notify.py,sha256=B4QMziSLkzETPQE6m3PuAEUC_pxgYG9tpfz-LIKBuRk,3729
+magiccampus_cli/commands/user.py,sha256=yuWIJowHZstsmFurfPMEbTmyTb_7DeTKWPWDQEe1VpM,2361
+magiccampus_sdk/__init__.py,sha256=nL0AlWeOW-UvIJ8Wv2OgbdZUSrH2yFGGqqCWaTfcaSk,4838
+magiccampus_sdk/auth.py,sha256=CPJIgOrc6pdXNU3rZFFeSsadbOoCU8FfwDqnxmD7wPw,3423
+magiccampus_sdk/client.py,sha256=c6bX5iGKEAc157sS742KDN6RU1JurdTARUrnpkRP78I,2912
+magiccampus_sdk/example.py,sha256=1ZsVTmABesIpfHf0HNGBg3aLfhsqpK4aE_Xi9zVvYSM,1276
+magiccampus_sdk/example_ws.py,sha256=SeSs_3kIx5FFzKHgFuCOOJYUCGt5vgQ2rra9ntkDPbs,1833
+magiccampus_sdk/feed_client.py,sha256=zpGEdOsMmys0vtmmfGC5biHQ1bllaxFZjKXyXQgX8Vc,566
+magiccampus_sdk/models.py,sha256=dC54GbAsNUK8CXEHd0Rew9HQuizYHTBorrHIdsfPjQ8,5970
+magiccampus_sdk/platform_client.py,sha256=-1381AmkZ2p74ut_obBF1Sad3wNIwC6CfudUDEV3QlU,4618
+magiccampus_sdk/platform_http.py,sha256=NxFPXcLs9wY2QwNh0rj_9NkIEZJZKhmSnd4bah5ZO9E,1995
+magiccampus_sdk/platform_ws.py,sha256=gZYcHyq6s38-2a6QwiVHngqPxBlv-tvhXI0i20DBE-g,4330
+magiccampus_sdk/user_client.py,sha256=R7_nqkPZOh6RLH-HTkdUWOwExV0rw9M2dojU5Fxp9_c,1328
+magiccampus_sdk/user_info_api.py,sha256=W1AEya19aV5QYW8-2k_0L_ePS31s3MX1dlRVergRkDk,1763
+magiccampus_sdk/im/__init__.py,sha256=Jt5qXuYi1uh7x0JsPwf7PcXRdJIDgql0vCQxb7ffyiY,3177
+magiccampus_sdk/im/client.py,sha256=L7OL98lZJSODsXg71oOnFzYJfdCdjV0P5WJYyAaRqKI,33509
+magiccampus_sdk/im/gob_codec.py,sha256=Uafb9SIEDeS6KlD1yndWvzMUwAaIlftmyg8eJGxheqI,9386
+magiccampus_sdk/im/http_api.py,sha256=qgtgs1LxlA9vRvHj0rJ0vEFC6L2azv5E4EiJMoDIVTw,2094
+magiccampus_sdk/im/media.py,sha256=fgXdm5EZcFzqmjFTFgx3KVugaphIVRQFKugx2VeHy3Y,25641
+magiccampus_sdk/im/models.py,sha256=O5_wvOA_uQib11HwbZsTz5JestwJ6Ia3aMsb76Znt3I,19170
+magiccampus_sdk/im/self_user_info_api.py,sha256=5flZrEVLIRd28AIk2V1qeAGmvRsy6v4oR7IbWQIGatg,1408
+magiccampus_sdk/im/storage.py,sha256=Jt7kwMbyHfeSNMg0aVHu3cZmtq1Z6gqAONYdAXVWIBE,7742
+magiccampus_sdk/im/text.py,sha256=vAnJrr4n2-ngRcRQIA2LlgJtpcihZcvCmJFHktl0KBY,1703
+magiccampus_sdk/im/ws_client.py,sha256=a3pNKjw74e74K2WaKLqEd8wguC_kURLUwlGpboDLYjA,45611
+magiccampus_sdk/im/proto/__init__.py,sha256=auqeK5gGo0RuuOj-q_2EHV_QiSzfwWZYb7cJQsh5fGE,490
+magiccampus_sdk/im/proto/sdkws/__init__.py,sha256=_7YAtN3EZzkli5KjDykOU-efPqOaTDYSAXEvtjFPBnQ,28
+magiccampus_sdk/im/proto/sdkws/sdkws_pb2.py,sha256=m9ZfzJr6UUbba-j0tsK-6qe1bro5-wVe6BvxoHYwr_w,32349
+magiccampus_sdk/im/proto/wrapperspb/__init__.py,sha256=_7YAtN3EZzkli5KjDykOU-efPqOaTDYSAXEvtjFPBnQ,28
+magiccampus_sdk/im/proto/wrapperspb/wrapperspb_pb2.py,sha256=nO0wYxrJyCLLB0_rmowidpalKYHD9EnWd3DbsKz5-uI,2160
+magic_campus_sdk-0.1.0.dist-info/METADATA,sha256=RjEwQG2MmvGL7LhPSowSRoMFohm2gVM0Osm7cYVoQ5k,4743
+magic_campus_sdk-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+magic_campus_sdk-0.1.0.dist-info/entry_points.txt,sha256=UBHHJkoSwWB6A3of7m1A4m40pK-qJMGVKodCcfOLywA,63
+magic_campus_sdk-0.1.0.dist-info/top_level.txt,sha256=N-wijR5BdV8-iLhE9AuPoZ5PUhKrl1I5yTszUw7TQAs,32
+magic_campus_sdk-0.1.0.dist-info/RECORD,,

magic_campus_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

magic_campus_sdk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+magic-campus = magiccampus_cli.__main__:main

magic_campus_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+magiccampus_cli
+magiccampus_sdk

magiccampus_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

magiccampus_cli/__main__.py

@@ -0,0 +1,9 @@
+from .cli import main as cli_main
+
+
+def main() -> int:
+    return cli_main()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

magiccampus_cli/accounts.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from magiccampus_sdk.auth import normalize_apiurl, normalize_platform
+
+from .utils import env_string, mask_secret, trim_string
+
+
+@dataclass(frozen=True)
+class AccountConfig:
+    account_id: str
+    enabled: bool
+    apiurl: str
+    apikey: str
+    platform: str
+
+
+def account_config_to_raw(account: AccountConfig) -> dict[str, object]:
+    return {
+        "enabled": account.enabled,
+        "apiUrl": account.apiurl,
+        "apiKey": account.apikey,
+        "platform": account.platform,
+    }
+
+
+def normalize_stored_account(raw: object) -> dict[str, object]:
+    source = raw if isinstance(raw, dict) else {}
+    apiurl = trim_string(source.get("apiUrl") or source.get("apiurl"))
+    platform = trim_string(source.get("platform")) or "IOS"
+    normalized: dict[str, object] = {
+        "enabled": source.get("enabled") is not False,
+        "apiUrl": normalize_apiurl(apiurl) if apiurl else "",
+        "apiKey": trim_string(source.get("apiKey") or source.get("apikey")),
+        "platform": normalize_platform(platform),
+    }
+    return normalized
+
+
+def env_default_account() -> dict[str, object] | None:
+    apiurl = env_string("MAGICCAMPUS_APIURL")
+    apikey = env_string("MAGICCAMPUS_APIKEY")
+    if not apiurl or not apikey:
+        return None
+
+    return {
+        "enabled": True,
+        "apiUrl": apiurl,
+        "apiKey": apikey,
+        "platform": env_string("MAGICCAMPUS_PLATFORM") or "IOS",
+    }
+
+
+def normalize_account(account_id: str, raw: object) -> AccountConfig | None:
+    stored = normalize_stored_account(raw)
+    if not stored["apiUrl"] or not stored["apiKey"]:
+        return None
+
+    return AccountConfig(
+        account_id=account_id,
+        enabled=stored.get("enabled") is not False,
+        apiurl=str(stored["apiUrl"]),
+        apikey=str(stored["apiKey"]),
+        platform=str(stored["platform"]),
+    )
+
+
+def list_account_ids(root: dict[str, object]) -> list[str]:
+    accounts = root.get("accounts")
+    ids = list(accounts.keys()) if isinstance(accounts, dict) else []
+    if env_default_account() and "default" not in ids:
+        ids.insert(0, "default")
+    return ids
+
+
+def get_account_config(root: dict[str, object], account_id: str | None) -> AccountConfig | None:
+    resolved_id = account_id or str(root.get("defaultAccountId") or "default")
+    if resolved_id == "default":
+        env_account = env_default_account()
+        if env_account is not None:
+            return normalize_account("default", env_account)
+
+    accounts = root.get("accounts")
+    configured = accounts.get(resolved_id) if isinstance(accounts, dict) else None
+    if configured is not None:
+        return normalize_account(resolved_id, configured)
+    return None
+
+
+def list_account_summaries(root: dict[str, object]) -> list[dict[str, object]]:
+    summaries: list[dict[str, object]] = []
+    default_account_id = str(root.get("defaultAccountId") or "default")
+    for account_id in list_account_ids(root):
+        account = get_account_config(root, account_id)
+        if account is None:
+            continue
+        summaries.append(
+            {
+                "accountId": account.account_id,
+                "default": account.account_id == default_account_id,
+                "enabled": account.enabled,
+                "apiUrl": account.apiurl,
+                "platform": account.platform,
+            }
+        )
+    return summaries
+
+
+def upsert_stored_account(root: dict[str, object], account_id: str, raw_account: dict[str, object], make_default: bool = False) -> dict[str, object]:
+    accounts = root.get("accounts")
+    next_accounts = dict(accounts) if isinstance(accounts, dict) else {}
+    next_accounts[account_id] = normalize_stored_account(raw_account)
+    default_account_id = account_id if make_default else str(root.get("defaultAccountId") or account_id)
+    return {"defaultAccountId": default_account_id, "accounts": next_accounts}
+
+
+def remove_stored_account(root: dict[str, object], account_id: str) -> dict[str, object]:
+    accounts = root.get("accounts")
+    next_accounts = dict(accounts) if isinstance(accounts, dict) else {}
+    next_accounts.pop(account_id, None)
+    remaining_ids = list(next_accounts.keys())
+    default_account_id = str(root.get("defaultAccountId") or "default")
+    if default_account_id == account_id:
+        default_account_id = remaining_ids[0] if remaining_ids else "default"
+    return {"defaultAccountId": default_account_id, "accounts": next_accounts}

magiccampus_cli/cli.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import sys
+
+from . import __version__
+from .commands.auth import run_auth_command
+from .commands.config import run_config_command
+from .commands.feed import run_feed_command
+from .commands.im import run_im_command
+from .commands.notify import run_notify_command
+from .commands.user import run_user_command
+from .output import print_output
+
+
+def _has_explicit_output_format(argv: list[str]) -> bool:
+    return "--format" in argv
+
+
+def parse_argv(argv: list[str]) -> tuple[str, list[str]]:
+    args = list(argv)
+    output_format = "json"
+    index = 0
+    while index < len(args):
+        if args[index] == "--format":
+            if index + 1 >= len(args):
+                raise RuntimeError("--format requires a value.")
+            output_format = args[index + 1]
+            del args[index:index + 2]
+            continue
+        index += 1
+    return output_format, args
+
+
+def parse_options(argv: list[str]) -> tuple[dict[str, object], list[str]]:
+    options: dict[str, object] = {}
+    positionals: list[str] = []
+    index = 0
+    while index < len(argv):
+        value = argv[index]
+        if value.startswith("--"):
+            key = value[2:]
+            next_value = argv[index + 1] if index + 1 < len(argv) else None
+            if next_value is not None and not next_value.startswith("--"):
+                options[key] = next_value
+                index += 2
+                continue
+            options[key] = True
+            index += 1
+            continue
+        positionals.append(value)
+        index += 1
+    return options, positionals
+
+
+def usage() -> str:
+    return "\n".join(
+        [
+            "magic-campus",
+            "",
+            "Commands:",
+            "  config init [--account <id>] --apiurl <url> --apikey <token> [--platform <name> --enabled <bool> --default <bool>]",
+            "  config list",
+            "  config use <accountId>",
+            "  config remove <accountId>",
+            "  auth status [--account <id>]",
+            "  im notify send --to <user:ID|group:ID> (--text <text> | --image <path|url> | --file <path|url> | --video <path|url>) [--name <filename>] [--account <id>] [--dry-run]",
+            "  im notify history --to <user:ID|group:ID> [--limit <count>] [--account <id>]",
+            "  user get --id <userId> [--account <id>]",
+            "  feed list [--account <id>] [--limit <count>] [--cursor <value>]",
+            "  notify +send --to <user:ID|group:ID> (--text <text> | --image <path|url> | --file <path|url> | --video <path|url>) [--name <filename>] [--account <id>] [--dry-run] (compat)",
+            "  notify +history --to <user:ID|group:ID> [--limit <count>] [--account <id>] (compat)",
+            "",
+            "Global flags:",
+            "  --format json|pretty|table|ndjson",
+        ]
+    )
+
+
+def main(raw_argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if raw_argv is None else raw_argv)
+    try:
+        has_explicit_output_format = _has_explicit_output_format(argv)
+        output_format, args = parse_argv(argv)
+        if not args or "--help" in args or "-h" in args:
+            if not has_explicit_output_format:
+                sys.stdout.write(f"{usage()}\n")
+                return 0
+            print_output({"ok": True, "usage": usage()}, output_format)
+            return 0
+
+        if args[0] == "--version":
+            print_output({"ok": True, "version": __version__, "runtime": "python"}, output_format)
+            return 0
+
+        if args[0] == "config":
+            result = run_config_command(args[1] if len(args) > 1 else None, args[2:], parse_options)
+        elif args[0] == "auth":
+            result = run_auth_command(args[1] if len(args) > 1 else None, args[2:], parse_options)
+        elif args[0] == "im":
+            result = run_im_command(args[1] if len(args) > 1 else None, args[2:], parse_options)
+        elif args[0] == "user":
+            result = run_user_command(args[1] if len(args) > 1 else None, args[2:], parse_options)
+        elif args[0] == "feed":
+            result = run_feed_command(args[1] if len(args) > 1 else None, args[2:], parse_options)
+        elif args[0] == "notify":
+            result = run_notify_command(args[1] if len(args) > 1 else None, args[2:], parse_options)
+        else:
+            raise RuntimeError(f"Unknown command: {args[0]}")
+
+        print_output(result, output_format)
+        return 0
+    except Exception as error:
+        print_output({"ok": False, "error": str(error)}, output_format if "output_format" in locals() else "json")
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

magiccampus_cli/client.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
+
+from magiccampus_sdk.auth import resolve_platform_id
+
+from . import __version__
+from .accounts import AccountConfig
+from .config_store import get_runtime_data_dir
+from .utils import mask_secret
+
+if TYPE_CHECKING:
+    from magiccampus_sdk.platform_ws import MagicCampusWSSDK
+
+T = TypeVar("T")
+
+
+def _build_data_dir(account: AccountConfig) -> Path:
+    path = get_runtime_data_dir() / account.account_id
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def get_account_db_path(account_id: str, user_id: str) -> Path:
+    return get_runtime_data_dir() / account_id / f"OpenIM_pyws_{user_id}.db"
+
+
+def build_sdk(account: AccountConfig) -> "MagicCampusWSSDK":
+    from magiccampus_sdk.platform_ws import MagicCampusWSConfig, MagicCampusWSSDK
+
+    config = MagicCampusWSConfig(
+        apiurl=account.apiurl,
+        apikey=account.apikey,
+        platform=account.platform,
+        data_dir=str(_build_data_dir(account)),
+        timeout_seconds=30.0,
+        sdk_version=f"magic-campus/{__version__}",
+        auto_sync_on_connect=False,
+        auto_sync_on_reconnect=False,
+        auto_reconnect=False,
+        enable_heartbeat=False,
+    )
+    return MagicCampusWSSDK(config)
+
+
+def with_connected_sdk(account: AccountConfig, action: Callable[[Any], T]) -> T:
+    sdk = build_sdk(account)
+    sdk.login()
+    try:
+        sdk.start()
+        return action(sdk)
+    finally:
+        try:
+            time.sleep(0.25)
+        finally:
+            sdk.logout()
+
+
+def with_http_send_client(account: AccountConfig, action: Callable[[object], T]) -> T:
+    from .http_send import MagicCampusHTTPSendClient
+
+    client = MagicCampusHTTPSendClient(account)
+    client.login()
+    try:
+        return action(client)
+    finally:
+        client.logout()
+
+
+def get_auth_status(account: AccountConfig) -> dict[str, object]:
+    def _probe(sdk: MagicCampusWSSDK) -> dict[str, object]:
+        credentials = sdk.credentials
+        now = int(time.time())
+        expire_at = credentials.expire_time if credentials else 0
+        return {
+            "ok": True,
+            "accountId": account.account_id,
+            "userID": sdk.user_id,
+            "platformID": resolve_platform_id(account.platform),
+            "provider": "magiccampus",
+            "transport": "ws_client",
+            "connected": True,
+            "loginStatus": "connected",
+            "wsAddr": credentials.ws_addr if credentials else "",
+            "apiAddr": credentials.api_addr if credentials else "",
+            "magiccampus": {
+                "enabled": account.enabled,
+                "platform": account.platform,
+                "apiUrl": account.apiurl,
+                "apiKeyPreview": mask_secret(account.apikey),
+                "expireAt": expire_at,
+                "expiresInSeconds": max(0, expire_at - now) if expire_at else 0,
+                "dataDir": str(_build_data_dir(account)),
+            },
+        }
+
+    return with_connected_sdk(account, _probe)

magiccampus_cli/commands/auth.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from ..accounts import get_account_config
+from ..config_store import read_config_root
+
+
+def resolve_account_or_throw(root: dict[str, object], account_id: str | None):
+    account = get_account_config(root, account_id)
+    if account is None:
+        resolved = account_id or str(root.get("defaultAccountId") or "default")
+        raise RuntimeError(
+            f"No usable MagicCampus account found for '{resolved}'. Run 'config init' or set MAGICCAMPUS_* env vars."
+        )
+    return account
+
+
+def run_auth_command(subcommand: str | None, argv: list[str], parse_options):
+    if subcommand != "status":
+        raise RuntimeError(f"Unknown auth subcommand: {subcommand}")
+
+    options, _ = parse_options(argv)
+    root = read_config_root()
+    account = resolve_account_or_throw(root, options.get("account"))
+    from ..client import get_auth_status
+
+    return get_auth_status(account)