lansenger-cli 0.1.0__py3-none-any.whl

lansenger_cli/commands/calendar.py

@@ -0,0 +1,154 @@
+import typer
+import json
+from typing import List
+
+from lansenger_cli.utils import get_client, output_result, output_list
+
+app = typer.Typer(help="Calendar and schedule operations")
+
+
+@app.command("primary")
+def fetch_primary_calendar(
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    user_id: str = typer.Option("", "--user-id", help="User ID"),
+):
+    client = get_client()
+    result = client.fetch_primary_calendar(user_token=user_token, user_id=user_id)
+    output_result(result, fields=[
+        "calendar_id", "summary", "description", "permissions", "role",
+    ], title="Primary Calendar")
+
+
+@app.command("create-schedule")
+def create_schedule(
+    calendar_id: str = typer.Argument(help="Calendar ID"),
+    summary: str = typer.Argument(help="Schedule summary/title"),
+    start_time: str = typer.Argument(help="Start time as JSON: '{\"dateTime\":\"2026-01-01T09:00:00\",\"timeZone\":\"Asia/Shanghai\"}'"),
+    end_time: str = typer.Argument(help="End time as JSON"),
+    attendees: str = typer.Argument(help="Attendees as JSON list: '[{\"staffId\":\"xxx\"}]'"),
+    description: str = typer.Option("", "--desc", "-d", help="Schedule description"),
+    all_day: str = typer.Option("no", "--all-day", help="yes or no"),
+    repeat_type: str = typer.Option("no", "--repeat", help="Repeat type: no, daily, weekly, monthly, yearly"),
+    reminder_type: str = typer.Option("yes", "--reminder", help="Reminder type: yes or no"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    user_id: str = typer.Option("", "--user-id", help="User ID"),
+):
+    client = get_client()
+    start_time_dict = json.loads(start_time)
+    end_time_dict = json.loads(end_time)
+    attendees_list = json.loads(attendees)
+    result = client.create_schedule(
+        calendar_id=calendar_id, summary=summary,
+        start_time=start_time_dict, end_time=end_time_dict,
+        attendees=attendees_list, description=description,
+        all_day=all_day, repeat_type=repeat_type,
+        reminder_type=reminder_type,
+        user_token=user_token, user_id=user_id,
+    )
+    output_result(result, fields=["schedule_id"], title="Create Schedule Result")
+
+
+@app.command("fetch-schedule")
+def fetch_schedule(
+    calendar_id: str = typer.Argument(help="Calendar ID"),
+    schedule_id: str = typer.Argument(help="Schedule ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    user_id: str = typer.Option("", "--user-id", help="User ID"),
+):
+    client = get_client()
+    result = client.fetch_schedule(
+        calendar_id=calendar_id, schedule_id=schedule_id,
+        user_token=user_token, user_id=user_id,
+    )
+    output_result(result, fields=[
+        "schedule_id", "summary", "description", "all_day",
+        "start_time", "end_time", "creator", "rsvp_status",
+    ], title="Schedule Info")
+
+
+@app.command("delete-schedule")
+def delete_schedule(
+    calendar_id: str = typer.Argument(help="Calendar ID"),
+    schedule_id: str = typer.Argument(help="Schedule ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    user_id: str = typer.Option("", "--user-id", help="User ID"),
+):
+    client = get_client()
+    result = client.delete_schedule(
+        calendar_id=calendar_id, schedule_id=schedule_id,
+        user_token=user_token, user_id=user_id,
+    )
+    output_result(result, fields=["schedule_id"], title="Delete Schedule Result")
+
+
+@app.command("list-schedules")
+def fetch_schedule_list(
+    calendar_id: str = typer.Argument(help="Calendar ID"),
+    start_time: int = typer.Argument(help="Start time (unix timestamp)"),
+    end_time: int = typer.Argument(help="End time (unix timestamp)"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    user_id: str = typer.Option("", "--user-id", help="User ID"),
+):
+    client = get_client()
+    result = client.fetch_schedule_list(
+        calendar_id=calendar_id, start_time=start_time, end_time=end_time,
+        user_token=user_token, user_id=user_id,
+    )
+    if result.success and result.schedule_list:
+        output_list(result.schedule_list, columns=["Schedule ID", "Summary"], row_mapper=lambda s: [
+            getattr(s, "schedule_id", ""), getattr(s, "summary", ""),
+        ])
+    else:
+        output_result(result, title="Schedule List")
+
+
+@app.command("attendees")
+def fetch_schedule_attendees(
+    calendar_id: str = typer.Argument(help="Calendar ID"),
+    schedule_id: str = typer.Argument(help="Schedule ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    user_id: str = typer.Option("", "--user-id", help="User ID"),
+    page: int = typer.Option(1, "--page", "-p", help="Page number"),
+    page_size: int = typer.Option(500, "--size", "-s", help="Page size"),
+):
+    client = get_client()
+    result = client.fetch_schedule_attendees(
+        calendar_id=calendar_id, schedule_id=schedule_id,
+        user_token=user_token, user_id=user_id,
+        page=page, page_size=page_size,
+    )
+    output_result(result, fields=["total"], title="Schedule Attendees")
+
+
+@app.command("add-attendees")
+def add_schedule_attendees(
+    calendar_id: str = typer.Argument(help="Calendar ID"),
+    schedule_id: str = typer.Argument(help="Schedule ID"),
+    attendees: str = typer.Argument(help="Attendee staff IDs as JSON list: '[\"id1\",\"id2\"]'"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    user_id: str = typer.Option("", "--user-id", help="User ID"),
+):
+    client = get_client()
+    attendees_list = json.loads(attendees)
+    result = client.add_schedule_attendees(
+        calendar_id=calendar_id, schedule_id=schedule_id,
+        attendees=attendees_list, user_token=user_token, user_id=user_id,
+    )
+    output_result(result, fields=["schedule_id"], title="Add Attendees Result")
+
+
+@app.command("delete-attendees")
+def delete_schedule_attendees(
+    calendar_id: str = typer.Argument(help="Calendar ID"),
+    schedule_id: str = typer.Argument(help="Schedule ID"),
+    attendees: str = typer.Argument(help="Attendee staff IDs as JSON list"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    user_id: str = typer.Option("", "--user-id", help="User ID"),
+):
+    client = get_client()
+    attendees_list = json.loads(attendees)
+    result = client.delete_schedule_attendees(
+        calendar_id=calendar_id, schedule_id=schedule_id,
+        attendees=attendees_list, user_token=user_token, user_id=user_id,
+    )
+    output_result(result, fields=["schedule_id"], title="Delete Attendees Result")

lansenger_cli/commands/callback.py

@@ -0,0 +1,64 @@
+import typer
+import json
+from rich import print as rprint
+
+from lansenger_cli.utils import is_json_output, console
+
+app = typer.Typer(help="Parse and verify callback events")
+
+
+@app.command("parse-payload")
+def parse_callback_payload(
+    encrypted_data: str = typer.Argument(help="Encrypted callback data"),
+    encoding_key: str = typer.Option("", "--encoding-key", help="Encoding key for decryption"),
+    verify_signature: bool = typer.Option(False, "--verify-sig", help="Verify signature"),
+    timestamp: str = typer.Option("", "--timestamp", help="Timestamp for signature verification"),
+    nonce: str = typer.Option("", "--nonce", help="Nonce for signature verification"),
+    signature: str = typer.Option("", "--signature", help="Signature to verify"),
+):
+    from lansenger_sdk import parse_callback_payload
+    events = parse_callback_payload(
+        encrypted_data,
+        encoding_key=encoding_key,
+        verify_signature=verify_signature,
+        timestamp=timestamp,
+        nonce=nonce,
+        signature=signature,
+    )
+    if is_json_output():
+        rprint(json.dumps([e.to_dict() if hasattr(e, "to_dict") else str(e) for e in events], indent=2, ensure_ascii=False))
+        return
+    for event in events:
+        rprint(f"[bold cyan]Event #{event.event_id}[/bold cyan] — {event.event_type} ({event.category})")
+        if hasattr(event, "data") and hasattr(event.data, "to_dict"):
+            rprint(json.dumps(event.data.to_dict(), indent=2, ensure_ascii=False))
+        else:
+            rprint(event.data)
+
+
+@app.command("verify-signature")
+def verify_callback_signature(
+    timestamp: str = typer.Argument(help="Timestamp"),
+    nonce: str = typer.Argument(help="Nonce"),
+    signature: str = typer.Argument(help="Signature"),
+    encoding_key: str = typer.Argument(help="Encoding key"),
+):
+    from lansenger_sdk import verify_callback_signature
+    valid = verify_callback_signature(timestamp, nonce, signature, encoding_key)
+    rprint(f"Signature valid: {valid}")
+
+
+@app.command("event-types")
+def get_callback_event_types():
+    from lansenger_sdk import get_callback_event_types
+    types = get_callback_event_types()
+    if is_json_output():
+        rprint(json.dumps(types, indent=2, ensure_ascii=False))
+        return
+    from rich.table import Table
+    table = Table(title="Callback Event Types", show_header=True, header_style="bold cyan")
+    table.add_column("Event Type")
+    table.add_column("Category")
+    for event_type, category in types.items():
+        table.add_row(event_type, category)
+    console.print(table)

lansenger_cli/commands/config.py

@@ -0,0 +1,54 @@
+import typer
+from rich import print as rprint
+
+from lansenger_sdk import CredentialStore
+
+from lansenger_cli.utils import get_store, output_result, is_json_output
+
+app = typer.Typer(help="Manage CLI configuration (credentials, tokens)")
+
+VALID_KEYS = ["app_id", "app_secret", "api_gateway_url", "passport_url"]
+
+
+@app.command("set")
+def config_set(
+    key: str = typer.Argument(help=f"Config key: {', '.join(VALID_KEYS)}"),
+    value: str = typer.Argument(help="Config value"),
+):
+    if key not in VALID_KEYS:
+        rprint(f"[red]Error:[/red] Invalid key '{key}'. Valid keys: {', '.join(VALID_KEYS)}")
+        raise typer.Exit(1)
+    store = get_store()
+    creds = store.load_credentials()
+    creds[key] = value
+    store.save_credentials(
+        app_id=creds.get("app_id", ""),
+        app_secret=creds.get("app_secret", ""),
+        api_gateway_url=creds.get("api_gateway_url", ""),
+        passport_url=creds.get("passport_url", ""),
+    )
+    rprint(f"[green]Set[/green] {key} = {value}")
+
+
+@app.command("show")
+def config_show():
+    store = get_store()
+    if is_json_output():
+        rprint(store.load())
+        return
+    creds = store.load_credentials()
+    has = store.has_credentials()
+    full = store.has_full_config()
+    rprint(f"Credentials configured: {has}")
+    rprint(f"Full config available: {full}")
+    rprint(f"Store path: {store.path}")
+    for k, v in creds.items():
+        display = v if k in ("api_gateway_url", "passport_url") else ("***" if v else "(empty)")
+        rprint(f"  {k}: {display}")
+
+
+@app.command("clear")
+def config_clear():
+    store = get_store()
+    store.clear()
+    rprint("[green]Cleared[/green] all stored configuration.")

lansenger_cli/commands/department.py

@@ -0,0 +1,59 @@
+import typer
+
+from lansenger_cli.utils import get_client, output_result, output_list
+
+app = typer.Typer(help="Query department information")
+
+
+@app.command("detail")
+def fetch_department_detail(
+    department_id: str = typer.Argument(help="Department ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    tag_id: str = typer.Option("", "--tag-id", help="Tag ID"),
+):
+    client = get_client()
+    result = client.fetch_department_detail(
+        department_id=department_id, user_token=user_token, tag_id=tag_id,
+    )
+    output_result(result, fields=[
+        "id", "name", "parent_id", "has_children",
+        "normal_members", "inactive_members",
+    ], title="Department Detail")
+
+
+@app.command("children")
+def fetch_department_children(
+    department_id: str = typer.Argument(help="Department ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.fetch_department_children(department_id=department_id, user_token=user_token)
+    if result.success and result.departments:
+        output_list(result.departments, columns=["ID", "Name", "Parent ID", "Has Children"], row_mapper=lambda d: [
+            getattr(d, "id", ""), getattr(d, "name", ""),
+            getattr(d, "parent_id", ""), getattr(d, "has_children", ""),
+        ])
+    else:
+        output_result(result, title="Department Children")
+
+
+@app.command("staffs")
+def fetch_department_staffs(
+    department_id: str = typer.Argument(help="Department ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    page: int = typer.Option(1, "--page", "-p", help="Page number"),
+    page_size: int = typer.Option(100, "--size", "-s", help="Page size"),
+):
+    client = get_client()
+    result = client.fetch_department_staffs(
+        department_id=department_id, user_token=user_token,
+        page=page, page_size=page_size,
+    )
+    if result.success and result.staffs:
+        output_result(result, fields=["has_more", "total"], title="Department Staffs")
+        output_list(result.staffs, columns=["Staff ID", "Name", "Gender"], row_mapper=lambda s: [
+            getattr(s, "staff_id", ""), getattr(s, "name", ""),
+            getattr(s, "gender", ""),
+        ])
+    else:
+        output_result(result)

lansenger_cli/commands/group.py

@@ -0,0 +1,117 @@
+import typer
+from typing import Optional, List
+
+from lansenger_cli.utils import get_client, output_result, output_list
+
+app = typer.Typer(help="Manage groups")
+
+
+@app.command("create")
+def create_group(
+    name: str = typer.Argument(help="Group name"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    owner_id: str = typer.Option("", "--owner", help="Owner staff ID"),
+    description: str = typer.Option("", "--desc", "-d", help="Group description"),
+    avatar_id: str = typer.Option("", "--avatar", help="Avatar ID"),
+    staff_id_list: Optional[List[str]] = typer.Option(None, "--staff", help="Staff IDs to add"),
+    department_id_list: Optional[List[str]] = typer.Option(None, "--dept", help="Department IDs to add"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.create_group(
+        name=name, org_id=org_id, owner_id=owner_id,
+        description=description, avatar_id=avatar_id,
+        staff_id_list=staff_id_list, department_id_list=department_id_list,
+        user_token=user_token,
+    )
+    output_result(result, fields=["group_id", "total_members"], title="Create Group Result")
+
+
+@app.command("info")
+def fetch_group_info(
+    group_id: str = typer.Argument(help="Group ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.fetch_group_info(group_id=group_id, user_token=user_token)
+    output_result(result, fields=[
+        "name", "description", "owner", "creator", "state",
+        "manage_mode", "is_public", "max_members", "total_members",
+    ], title="Group Info")
+
+
+@app.command("members")
+def fetch_group_members(
+    group_id: str = typer.Argument(help="Group ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    page_offset: int = typer.Option(0, "--page", "-p", help="Page offset"),
+    page_size: int = typer.Option(100, "--size", "-s", help="Page size"),
+):
+    client = get_client()
+    result = client.fetch_group_members(
+        group_id=group_id, user_token=user_token,
+        page_offset=page_offset, page_size=page_size,
+    )
+    if result.success:
+        output_result(result, fields=["total_members"], title="Group Members")
+        if result.members:
+            output_list(result.members, columns=["Staff ID", "Name", "Role"], row_mapper=lambda m: [
+                getattr(m, "staff_id", ""), getattr(m, "name", ""), getattr(m, "role", "")
+            ])
+    else:
+        output_result(result)
+
+
+@app.command("list")
+def fetch_group_list(
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    page_offset: int = typer.Option(0, "--page", "-p", help="Page offset"),
+    page_size: int = typer.Option(100, "--size", "-s", help="Page size"),
+):
+    client = get_client()
+    result = client.fetch_group_list(user_token=user_token, page_offset=page_offset, page_size=page_size)
+    output_result(result, fields=["total_group_ids"], title="Group List")
+
+
+@app.command("check")
+def check_is_in_group(
+    group_id: str = typer.Argument(help="Group ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    staff_id: str = typer.Option("", "--staff-id", help="Staff ID to check"),
+):
+    client = get_client()
+    result = client.check_is_in_group(group_id=group_id, user_token=user_token, staff_id=staff_id)
+    output_result(result, fields=["is_in_group"], title="Is In Group")
+
+
+@app.command("update")
+def update_group_info(
+    group_id: str = typer.Argument(help="Group ID"),
+    name: str = typer.Option("", "--name", help="New group name"),
+    description: str = typer.Option("", "--desc", help="New description"),
+    owner_id: str = typer.Option("", "--owner", help="New owner ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.update_group_info(
+        group_id=group_id, name=name, description=description,
+        owner_id=owner_id, user_token=user_token,
+    )
+    output_result(result, title="Update Group Result")
+
+
+@app.command("update-members")
+def update_group_members(
+    group_id: str = typer.Argument(help="Group ID"),
+    add_user: Optional[List[str]] = typer.Option(None, "--add", help="Staff IDs to add"),
+    del_user: Optional[List[str]] = typer.Option(None, "--remove", help="Staff IDs to remove"),
+    add_dept: Optional[List[str]] = typer.Option(None, "--add-dept", help="Department IDs to add"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.update_group_members(
+        group_id=group_id, add_user_list=add_user,
+        del_user_list=del_user, add_department_id_list=add_dept,
+        user_token=user_token,
+    )
+    output_result(result, fields=["total_members", "added_staff_count", "deleted_staff_count"], title="Update Members Result")

lansenger_cli/commands/health.py

@@ -0,0 +1,17 @@
+import typer
+from rich import print as rprint
+
+from lansenger_cli.utils import get_client
+
+app = typer.Typer(help="Health check and connection verification")
+
+
+@app.command("check")
+def health_check():
+    client = get_client()
+    result = client.health_check()
+    if result:
+        rprint("[green]OK[/green] — Lansenger connection is healthy (app token obtained successfully)")
+    else:
+        rprint("[red]FAIL[/red] — Could not obtain app token. Check your credentials.")
+        raise typer.Exit(1)

lansenger_cli/commands/media.py

@@ -0,0 +1,42 @@
+import typer
+
+from lansenger_cli.utils import get_client, output_result
+
+app = typer.Typer(help="Upload and download media files")
+
+
+@app.command("upload")
+def upload_media(
+    file_path: str = typer.Argument(help="Local file path to upload"),
+    media_type: int = typer.Option(3, "--media-type", "-t", help="1=video, 2=image, 3=file"),
+):
+    client = get_client()
+    result = client.upload_media(file_path=file_path, media_type=media_type)
+    output_result(result, fields=["message_id"], title="Upload Media Result")
+
+
+@app.command("download")
+def download_media(
+    media_id: str = typer.Argument(help="Media ID to download"),
+):
+    client = get_client()
+    result = client.download_media(media_id=media_id)
+    if result.success:
+        from rich import print as rprint
+        rprint(f"[green]Downloaded media[/green] (size: {len(result.data) if result.data else 0} bytes)")
+    else:
+        output_result(result)
+
+
+@app.command("download-to-file")
+def download_media_to_file(
+    media_id: str = typer.Argument(help="Media ID to download"),
+    target_path: str = typer.Option("", "--output", "-o", help="Target file path"),
+    media_type: str = typer.Option("file", "--media-type", help="file, image, or video"),
+):
+    client = get_client()
+    saved_path = client.download_media_to_file(
+        media_id=media_id, target_path=target_path, media_type=media_type,
+    )
+    from rich import print as rprint
+    rprint(f"[green]Saved to:[/green] {saved_path}")

lansenger_cli/commands/message.py

@@ -0,0 +1,162 @@
+import typer
+from typing import Optional, List
+
+from lansenger_cli.utils import get_client, output_result, output_list
+
+app = typer.Typer(help="Send and manage messages")
+
+
+@app.command("send-text")
+def send_text(
+    chat_id: str = typer.Argument(help="Chat ID (user/group)"),
+    content: str = typer.Argument(help="Text content"),
+    file_path: str = typer.Option("", "--file", "-f", help="File path to attach"),
+    is_group: bool = typer.Option(False, "--group", "-g", help="Send as group message"),
+    reminder_all: bool = typer.Option(False, "--mention-all", help="@all in group"),
+    reminder_user_ids: Optional[List[str]] = typer.Option(None, "--mention", help="User IDs to @mention"),
+    user_token: str = typer.Option("", "--user-token", help="User token for private channel"),
+    sender_id: str = typer.Option("", "--sender-id", help="Sender staff ID for group message"),
+):
+    client = get_client()
+    result = client.send_text(
+        chat_id=chat_id,
+        content=content,
+        file_path=file_path,
+        is_group=is_group,
+        reminder_all=reminder_all,
+        reminder_user_ids=reminder_user_ids,
+        user_token=user_token,
+        sender_id=sender_id,
+    )
+    output_result(result, fields=["message_id", "msg_type", "operation"], title="Send Text Result")
+
+
+@app.command("send-markdown")
+def send_markdown(
+    chat_id: str = typer.Argument(help="Chat ID"),
+    content: str = typer.Argument(help="Markdown content"),
+):
+    client = get_client()
+    result = client.send_markdown(chat_id=chat_id, content=content)
+    output_result(result, fields=["message_id", "msg_type", "operation"], title="Send Markdown Result")
+
+
+@app.command("send-file")
+def send_file(
+    chat_id: str = typer.Argument(help="Chat ID"),
+    file_path: str = typer.Argument(help="Local file path"),
+    caption: str = typer.Option("", "--caption", "-c", help="Caption text"),
+    media_type: Optional[int] = typer.Option(None, "--media-type", help="1=video, 2=image, 3=file"),
+):
+    client = get_client()
+    result = client.send_file(
+        chat_id=chat_id,
+        file_path=file_path,
+        caption=caption,
+        media_type=media_type,
+    )
+    output_result(result, fields=["message_id", "msg_type", "operation"], title="Send File Result")
+
+
+@app.command("send-image-url")
+def send_image_url(
+    chat_id: str = typer.Argument(help="Chat ID"),
+    image_url: str = typer.Argument(help="Image URL to send"),
+    caption: str = typer.Option("", "--caption", "-c", help="Caption text"),
+):
+    client = get_client()
+    result = client.send_image_url(chat_id=chat_id, image_url=image_url, caption=caption)
+    output_result(result, fields=["message_id", "msg_type", "operation"], title="Send Image Result")
+
+
+@app.command("send-link-card")
+def send_link_card(
+    chat_id: str = typer.Argument(help="Chat ID"),
+    title: str = typer.Argument(help="Card title"),
+    link: str = typer.Argument(help="Card link URL"),
+    description: str = typer.Option("", "--desc", "-d", help="Card description"),
+    icon_link: str = typer.Option("", "--icon", help="Icon URL"),
+    pc_link: str = typer.Option("", "--pc-link", help="PC link URL"),
+    from_name: str = typer.Option("", "--from-name", help="Source name"),
+    from_icon_link: str = typer.Option("", "--from-icon", help="Source icon URL"),
+):
+    client = get_client()
+    result = client.send_link_card(
+        chat_id=chat_id, title=title, link=link,
+        description=description, icon_link=icon_link,
+        pc_link=pc_link, from_name=from_name, from_icon_link=from_icon_link,
+    )
+    output_result(result, fields=["message_id", "msg_type", "operation"], title="Send Link Card Result")
+
+
+@app.command("send-app-articles")
+def send_app_articles(
+    chat_id: str = typer.Argument(help="Chat ID"),
+    articles: List[str] = typer.Argument(help="Articles as JSON dicts, e.g. '{\"title\":\"T\",\"url\":\"U\"}'"),
+):
+    import json
+    parsed = [json.loads(a) for a in articles]
+    client = get_client()
+    result = client.send_app_articles(chat_id=chat_id, articles=parsed)
+    output_result(result, fields=["message_id", "msg_type", "operation"], title="Send App Articles Result")
+
+
+@app.command("send-app-card")
+def send_app_card(
+    chat_id: str = typer.Argument(help="Chat ID"),
+    body_title: str = typer.Argument(help="Card body title"),
+    head_title: str = typer.Option("", "--head-title", help="Card head title"),
+    body_sub_title: str = typer.Option("", "--sub-title", help="Card sub title"),
+    body_content: str = typer.Option("", "--content", help="Card body content"),
+    signature: str = typer.Option("", "--signature", help="Card signature"),
+    card_link: str = typer.Option("", "--card-link", help="Card link URL"),
+    pc_card_link: str = typer.Option("", "--pc-card-link", help="PC card link URL"),
+    is_dynamic: bool = typer.Option(False, "--dynamic", help="Enable dynamic card updates"),
+    staff_id: str = typer.Option("", "--staff-id", help="Staff ID"),
+    head_icon_url: str = typer.Option("", "--head-icon", help="Head icon URL"),
+):
+    client = get_client()
+    result = client.send_app_card(
+        chat_id=chat_id, body_title=body_title,
+        head_title=head_title, body_sub_title=body_sub_title,
+        body_content=body_content, signature=signature,
+        card_link=card_link, pc_card_link=pc_card_link,
+        is_dynamic=is_dynamic, staff_id=staff_id, head_icon_url=head_icon_url,
+    )
+    output_result(result, fields=["message_id", "msg_type", "operation"], title="Send App Card Result")
+
+
+@app.command("update-dynamic-card")
+def update_dynamic_card(
+    msg_id: str = typer.Argument(help="Message ID of the dynamic card"),
+    is_last_update: bool = typer.Option(False, "--last", help="Mark as last update"),
+):
+    client = get_client()
+    result = client.update_dynamic_card(msg_id=msg_id, is_last_update=is_last_update)
+    output_result(result, fields=["message_id", "operation"], title="Update Dynamic Card Result")
+
+
+@app.command("revoke")
+def revoke_message(
+    message_ids: List[str] = typer.Argument(help="Message IDs to revoke"),
+    chat_type: str = typer.Option("bot", "--chat-type", help="bot, account, or private"),
+    sender_id: str = typer.Option("", "--sender-id", help="Sender staff ID"),
+):
+    client = get_client()
+    result = client.revoke_message(message_ids=message_ids, chat_type=chat_type, sender_id=sender_id)
+    output_result(result, fields=["message_id", "operation"], title="Revoke Message Result")
+
+
+@app.command("query-groups")
+def query_groups(
+    page_offset: int = typer.Option(1, "--page", "-p", help="Page offset"),
+    page_size: int = typer.Option(100, "--size", "-s", help="Page size"),
+):
+    client = get_client()
+    result = client.query_groups(page_offset=page_offset, page_size=page_size)
+    if result.success:
+        output_result(result, fields=["total_group_ids", "operation"], title="Query Groups Result")
+        if result.group_ids:
+            output_list(result.group_ids, columns=["Group ID"], title="Groups", row_mapper=lambda gid: [gid])
+    else:
+        output_result(result)

lansenger_cli/commands/oauth.py

@@ -0,0 +1,73 @@
+import typer
+from rich import print as rprint
+
+from lansenger_cli.utils import get_client, output_result
+
+app = typer.Typer(help="OAuth2 user authentication operations")
+
+
+@app.command("authorize-url")
+def build_authorize_url(
+    redirect_uri: str = typer.Argument(help="Redirect URI after auth"),
+    scope: str = typer.Option("basic_userinfor", "--scope", "-s", help="OAuth2 scope"),
+    state: str = typer.Option("", "--state", help="State parameter for CSRF protection"),
+):
+    client = get_client()
+    url = client.build_authorize_url(redirect_uri=redirect_uri, scope=scope, state=state)
+    rprint(f"[green]Authorize URL:[/green] {url}")
+
+
+@app.command("exchange-code")
+def exchange_code(
+    code: str = typer.Argument(help="Authorization code from callback"),
+    redirect_uri: str = typer.Option("", "--redirect-uri", help="Redirect URI used in authorize"),
+):
+    client = get_client()
+    result = client.exchange_code(code=code, redirect_uri=redirect_uri)
+    output_result(result, fields=[
+        "user_token", "expires_in", "refresh_token",
+        "refresh_expires_in", "staff_id", "scope",
+    ], title="Exchange Code Result")
+
+
+@app.command("refresh-token")
+def refresh_user_token(
+    refresh_token: str = typer.Argument(help="Refresh token"),
+    scope: str = typer.Option("", "--scope", "-s", help="Scope"),
+):
+    client = get_client()
+    result = client.refresh_user_token(refresh_token=refresh_token, scope=scope)
+    output_result(result, fields=[
+        "user_token", "expires_in", "refresh_token", "staff_id",
+    ], title="Refresh Token Result")
+
+
+@app.command("user-info")
+def fetch_user_info(
+    user_token: str = typer.Argument(help="User token"),
+):
+    client = get_client()
+    result = client.fetch_user_info(user_token=user_token)
+    output_result(result, fields=[
+        "staff_id", "name", "org_id", "org_name",
+        "mobile_phone", "email", "employee_number",
+    ], title="User Info")
+
+
+@app.command("parse-callback")
+def parse_authorize_callback(
+    query_string: str = typer.Argument(help="Query string from callback URL"),
+):
+    from lansenger_sdk import LansengerSyncClient
+    params = LansengerSyncClient.parse_authorize_callback(query_string)
+    rprint(params)
+
+
+@app.command("validate-state")
+def validate_callback_state(
+    callback_state: str = typer.Argument(help="State from callback"),
+    expected_state: str = typer.Argument(help="Expected state you set"),
+):
+    from lansenger_sdk import LansengerSyncClient
+    valid = LansengerSyncClient.validate_callback_state(callback_state, expected_state)
+    rprint(f"State valid: {valid}")

lansenger_cli/commands/staff.py

@@ -0,0 +1,102 @@
+import typer
+from typing import Optional, List
+
+from lansenger_cli.utils import get_client, output_result, output_list
+
+app = typer.Typer(help="Query staff/contacts information")
+
+
+@app.command("basic-info")
+def fetch_staff_basic_info(
+    staff_id: str = typer.Argument(help="Staff ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.fetch_staff_basic_info(staff_id=staff_id, user_token=user_token)
+    output_result(result, fields=[
+        "org_id", "org_name", "name", "gender", "signature",
+        "avatar_url", "status", "departments",
+    ], title="Staff Basic Info")
+
+
+@app.command("detail")
+def fetch_staff_detail(
+    staff_id: str = typer.Argument(help="Staff ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.fetch_staff_detail(staff_id=staff_id, user_token=user_token)
+    output_result(result, fields=[
+        "org_id", "org_name", "name", "gender", "email",
+        "mobile_phone", "avatar_url", "career", "tags",
+    ], title="Staff Detail")
+
+
+@app.command("ancestors")
+def fetch_department_ancestors(
+    staff_id: str = typer.Argument(help="Staff ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.fetch_department_ancestors(staff_id=staff_id, user_token=user_token)
+    if result.success and result.ancestor_groups:
+        output_list(result.ancestor_groups, columns=["Department Group"], row_mapper=lambda g: [str(g)])
+    else:
+        output_result(result, title="Department Ancestors")
+
+
+@app.command("id-mapping")
+def fetch_staff_id_mapping(
+    org_id: str = typer.Argument(help="Organization ID"),
+    id_type: str = typer.Argument(help="ID type: phone, email, login_name, external_id"),
+    id_value: str = typer.Argument(help="ID value to map"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.fetch_staff_id_mapping(
+        org_id=org_id, id_type=id_type, id_value=id_value, user_token=user_token,
+    )
+    output_result(result, fields=["staff_id"], title="Staff ID Mapping")
+
+
+@app.command("org-extra-fields")
+def fetch_org_extra_field_ids(
+    org_id: str = typer.Argument(help="Organization ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    page: int = typer.Option(1, "--page", "-p", help="Page number"),
+    page_size: int = typer.Option(1000, "--size", "-s", help="Page size"),
+):
+    client = get_client()
+    result = client.fetch_org_extra_field_ids(
+        org_id=org_id, user_token=user_token, page=page, page_size=page_size,
+    )
+    output_result(result, fields=["has_more", "total"], title="Org Extra Fields")
+
+
+@app.command("search")
+def search_staff(
+    keyword: str = typer.Argument(help="Search keyword"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    user_id: str = typer.Option("", "--user-id", help="User ID context"),
+    recursive: bool = typer.Option(True, "--recursive/--no-recursive", help="Recursive search"),
+    sector_ids: Optional[List[str]] = typer.Option(None, "--sector", help="Sector IDs"),
+    page: Optional[int] = typer.Option(None, "--page", "-p", help="Page number"),
+    page_size: Optional[int] = typer.Option(None, "--size", "-s", help="Page size"),
+):
+    client = get_client()
+    result = client.search_staff(
+        keyword=keyword, user_token=user_token, user_id=user_id,
+        recursive=recursive, sector_ids=sector_ids,
+        page=page, page_size=page_size,
+    )
+    output_result(result, fields=["has_more", "total"], title="Staff Search")
+
+
+@app.command("org-info")
+def fetch_org_info(
+    org_id: str = typer.Argument(help="Organization ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.fetch_org_info(org_id=org_id, user_token=user_token)
+    output_result(result, fields=["org_id", "org_name", "icon_url"], title="Org Info")

lansenger_cli/commands/streaming.py

@@ -0,0 +1,27 @@
+import typer
+
+from lansenger_cli.utils import get_client, output_result
+
+app = typer.Typer(help="Streaming message operations (for AI agent progressive output)")
+
+
+@app.command("create")
+def create_stream_message(
+    receiver_id: str = typer.Argument(help="Receiver ID"),
+    receiver_type: str = typer.Argument(help="Receiver type: single or group"),
+    stream_id: str = typer.Argument(help="Stream ID (unique per session)"),
+):
+    client = get_client()
+    result = client.create_stream_message(
+        receiver_id=receiver_id, receiver_type=receiver_type, stream_id=stream_id,
+    )
+    output_result(result, fields=["message_id"], title="Create Stream Message Result")
+
+
+@app.command("fetch")
+def fetch_stream_message(
+    msg_id: str = typer.Argument(help="Message ID of the stream message"),
+):
+    client = get_client()
+    result = client.fetch_stream_message(msg_id=msg_id)
+    output_result(result, fields=["message_id"], title="Fetch Stream Message Result")

lansenger_cli/commands/todo.py

@@ -0,0 +1,220 @@
+import typer
+import json
+from typing import Optional, List
+
+from lansenger_cli.utils import get_client, output_result, output_list
+
+app = typer.Typer(help="Manage todo tasks")
+
+
+@app.command("create")
+def create_todo_task(
+    title: str = typer.Argument(help="Task title"),
+    link: str = typer.Argument(help="Task link URL"),
+    pc_link: str = typer.Argument(help="PC link URL"),
+    executor_ids: str = typer.Argument(help="Executor IDs as comma-separated list"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    type: int = typer.Option(1, "--type", "-t", help="1=notification, 2=approval"),
+    source_id: str = typer.Option("", "--source-id", help="Source ID"),
+    desc: str = typer.Option("", "--desc", "-d", help="Task description"),
+    sender_id: str = typer.Option("", "--sender-id", help="Sender staff ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    ids = executor_ids.split(",")
+    result = client.create_todo_task(
+        title=title, link=link, pc_link=pc_link,
+        executor_ids=ids, org_id=org_id, type=type,
+        source_id=source_id, desc=desc,
+        sender_id=sender_id, user_token=user_token,
+    )
+    output_result(result, fields=["todotask_id"], title="Create Todo Result")
+
+
+@app.command("update")
+def update_todo_task(
+    todotask_id: str = typer.Argument(help="Todo task ID"),
+    title: str = typer.Argument(help="New title"),
+    link: str = typer.Argument(help="New link URL"),
+    pc_link: str = typer.Argument(help="New PC link URL"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    desc: str = typer.Option("", "--desc", "-d", help="New description"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.update_todo_task(
+        todotask_id=todotask_id, title=title, link=link,
+        pc_link=pc_link, org_id=org_id, desc=desc,
+        user_token=user_token,
+    )
+    output_result(result, fields=["todotask_id"], title="Update Todo Result")
+
+
+@app.command("update-status")
+def update_todo_task_status(
+    todotask_id: str = typer.Argument(help="Todo task ID"),
+    status: str = typer.Argument(help="Status: 11=pending read, 12=read, 21=pending do, 22=done"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    staff_id: str = typer.Option("", "--staff-id", help="Staff ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.update_todo_task_status(
+        todotask_id=todotask_id, status=status, org_id=org_id,
+        staff_id=staff_id, user_token=user_token,
+    )
+    output_result(result, fields=["todotask_id"], title="Update Todo Status Result")
+
+
+@app.command("delete")
+def delete_todo_task(
+    todotask_id: str = typer.Argument(help="Todo task ID"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    staff_id: str = typer.Option("", "--staff-id", help="Staff ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.delete_todo_task(
+        todotask_id=todotask_id, org_id=org_id,
+        staff_id=staff_id, user_token=user_token,
+    )
+    output_result(result, fields=["todotask_id"], title="Delete Todo Result")
+
+
+@app.command("list")
+def fetch_todo_task_list(
+    org_id: str = typer.Argument(help="Organization ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+    app_ids: Optional[str] = typer.Option(None, "--app-ids", help="App IDs (comma-separated)"),
+    staff_id: str = typer.Option("", "--staff-id", help="Staff ID"),
+    status_list: Optional[str] = typer.Option(None, "--status", help="Status list (comma-separated)"),
+):
+    client = get_client()
+    app_ids_list = app_ids.split(",") if app_ids else None
+    status_list_parsed = status_list.split(",") if status_list else None
+    result = client.fetch_todo_task_list(
+        org_id=org_id, user_token=user_token,
+        app_ids=app_ids_list, staff_id=staff_id,
+        status_list=status_list_parsed,
+    )
+    output_result(result, fields=["total"], title="Todo Task List")
+
+
+@app.command("fetch-by-source")
+def fetch_todo_task_by_source_id(
+    source_id: str = typer.Argument(help="Source ID"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    staff_id: str = typer.Option("", "--staff-id", help="Staff ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.fetch_todo_task_by_source_id(
+        source_id=source_id, org_id=org_id,
+        staff_id=staff_id, user_token=user_token,
+    )
+    output_result(result, fields=[
+        "todotask_id", "source_id", "title", "desc",
+        "status", "type", "link", "executor_ids",
+    ], title="Todo Task")
+
+
+@app.command("fetch-by-id")
+def fetch_todo_task_by_id(
+    todotask_id: str = typer.Argument(help="Todo task ID"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    staff_id: str = typer.Option("", "--staff-id", help="Staff ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    result = client.fetch_todo_task_by_id(
+        todotask_id=todotask_id, org_id=org_id,
+        staff_id=staff_id, user_token=user_token,
+    )
+    output_result(result, fields=[
+        "todotask_id", "source_id", "title", "desc",
+        "status", "type", "link", "executor_ids",
+    ], title="Todo Task")
+
+
+@app.command("status-counts")
+def fetch_todo_task_status_counts(
+    staff_id: str = typer.Argument(help="Staff ID"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    app_id: str = typer.Option("", "--app-id", help="App ID"),
+    status_list: Optional[str] = typer.Option(None, "--status", help="Status list (comma-separated)"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    status_parsed = status_list.split(",") if status_list else None
+    result = client.fetch_todo_task_status_counts(
+        staff_id=staff_id, org_id=org_id,
+        app_id=app_id, status_list=status_parsed,
+        user_token=user_token,
+    )
+    output_result(result, fields=["status_counts"], title="Todo Status Counts")
+
+
+@app.command("executor-status")
+def update_executor_status(
+    executor_status_list: str = typer.Argument(help="Executor status list as JSON: '[{\"executorId\":\"x\",\"status\":\"22\"}]'"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    todotask_id: str = typer.Option("", "--task-id", help="Todo task ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    parsed = json.loads(executor_status_list)
+    result = client.update_executor_status(
+        executor_status_list=parsed, org_id=org_id,
+        todotask_id=todotask_id, user_token=user_token,
+    )
+    output_result(result, fields=["todotask_id"], title="Update Executor Status Result")
+
+
+@app.command("add-executors")
+def add_executors(
+    executor_ids: str = typer.Argument(help="Executor IDs (comma-separated)"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    todotask_id: str = typer.Option("", "--task-id", help="Todo task ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    ids = executor_ids.split(",")
+    result = client.add_executors(
+        executor_ids=ids, org_id=org_id,
+        todotask_id=todotask_id, user_token=user_token,
+    )
+    output_result(result, fields=["todotask_id"], title="Add Executors Result")
+
+
+@app.command("delete-executors")
+def delete_executors(
+    executor_ids: str = typer.Argument(help="Executor IDs (comma-separated)"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    todotask_id: str = typer.Option("", "--task-id", help="Todo task ID"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    ids = executor_ids.split(",")
+    result = client.delete_executors(
+        executor_ids=ids, org_id=org_id,
+        todotask_id=todotask_id, user_token=user_token,
+    )
+    output_result(result, fields=["todotask_id"], title="Delete Executors Result")
+
+
+@app.command("executor-list")
+def fetch_executor_list(
+    todotask_id: str = typer.Argument(help="Todo task ID"),
+    org_id: str = typer.Argument(help="Organization ID"),
+    staff_id: str = typer.Option("", "--staff-id", help="Staff ID"),
+    status_list: Optional[str] = typer.Option(None, "--status", help="Status list (comma-separated)"),
+    user_token: str = typer.Option("", "--user-token", help="User token"),
+):
+    client = get_client()
+    status_parsed = status_list.split(",") if status_list else None
+    result = client.fetch_executor_list(
+        todotask_id=todotask_id, org_id=org_id,
+        staff_id=staff_id, status_list=status_parsed,
+        user_token=user_token,
+    )
+    output_result(result, fields=["total"], title="Executor List")

lansenger_cli/main.py

@@ -0,0 +1,45 @@
+import typer
+
+from lansenger_cli.utils import get_store, output_result, is_json_output, console
+from lansenger_cli.commands import (
+    config as config_cmd,
+    message as message_cmd,
+    group as group_cmd,
+    staff as staff_cmd,
+    department as department_cmd,
+    calendar as calendar_cmd,
+    todo as todo_cmd,
+    oauth as oauth_cmd,
+    callback as callback_cmd,
+    media as media_cmd,
+    streaming as streaming_cmd,
+    health as health_cmd,
+)
+from lansenger_cli.utils import set_json_output
+
+app = typer.Typer(
+    name="lansenger",
+    help="Lansenger (蓝信) CLI — interact with Lansenger APIs from the command line.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+app.add_typer(config_cmd.app, name="config")
+app.add_typer(message_cmd.app, name="message")
+app.add_typer(group_cmd.app, name="group")
+app.add_typer(staff_cmd.app, name="staff")
+app.add_typer(department_cmd.app, name="department")
+app.add_typer(calendar_cmd.app, name="calendar")
+app.add_typer(todo_cmd.app, name="todo")
+app.add_typer(oauth_cmd.app, name="oauth")
+app.add_typer(callback_cmd.app, name="callback")
+app.add_typer(media_cmd.app, name="media")
+app.add_typer(streaming_cmd.app, name="streaming")
+app.add_typer(health_cmd.app, name="health")
+
+
+@app.callback()
+def global_options(
+    json: bool = typer.Option(False, "--json", "-j", help="Output raw JSON instead of formatted tables"),
+):
+    set_json_output(json)

lansenger_cli/utils.py

@@ -0,0 +1,79 @@
+from lansenger_sdk import LansengerSyncClient, CredentialStore, LansengerConfig
+from rich import print as rprint
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+_json_output = False
+
+
+def set_json_output(value: bool):
+    global _json_output
+    _json_output = value
+
+
+def is_json_output() -> bool:
+    return _json_output
+
+
+def get_store() -> CredentialStore:
+    return CredentialStore()
+
+
+def get_client(store_path: str = "") -> LansengerSyncClient:
+    store = CredentialStore(path=store_path) if store_path else CredentialStore()
+    creds = store.load_credentials()
+    if not creds.get("app_id") or not creds.get("app_secret"):
+        env_config = LansengerConfig.from_env()
+        if env_config.is_configured():
+            return LansengerSyncClient.from_config(env_config)
+        rprint("[red]Error:[/red] No credentials configured. Run [bold]lansenger config set[/bold] first, or set LANSENGER_APP_ID / LANSENGER_APP_SECRET env vars.")
+        raise SystemExit(1)
+    config = LansengerConfig(
+        app_id=creds["app_id"],
+        app_secret=creds["app_secret"],
+        api_gateway_url=creds.get("api_gateway_url", "https://open.e.lanxin.cn/open/apigw"),
+        passport_url=creds.get("passport_url", ""),
+    )
+    return LansengerSyncClient.from_config(config)
+
+
+def output_result(result, fields: list[str] | None = None, title: str = ""):
+    if is_json_output():
+        rprint(result.to_dict())
+        return
+    if not result.success:
+        rprint(f"[red]Error:[/red] {result.error}")
+        raise SystemExit(1)
+    if fields:
+        table = Table(title=title, show_header=True, header_style="bold cyan")
+        table.add_column("Field")
+        table.add_column("Value")
+        for f in fields:
+            val = getattr(result, f, None)
+            if val is not None:
+                if isinstance(val, (list, dict)):
+                    val = str(val)
+                table.add_row(f, str(val))
+        console.print(table)
+    else:
+        rprint(result.to_dict())
+
+
+def output_list(items: list, columns: list[str], title: str = "", row_mapper=None):
+    if is_json_output():
+        rprint([item.to_dict() if hasattr(item, "to_dict") else item for item in items])
+        return
+    if not items:
+        rprint("[yellow]No results.[/yellow]")
+        return
+    table = Table(title=title, show_header=True, header_style="bold cyan")
+    for col in columns:
+        table.add_column(col)
+    for item in items:
+        if row_mapper:
+            row = row_mapper(item)
+        else:
+            row = [str(getattr(item, col, "")) for col in columns]
+        table.add_row(*row)
+    console.print(table)

lansenger_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: lansenger-cli
+Version: 0.1.0
+Summary: CLI for Lansenger (蓝信) — send messages, manage groups, staff, departments, calendars, todos, and more
+Author: Lansenger PM Team
+License-Expression: MIT
+Keywords: lansenger,蓝信,cli,chatbot,messaging,enterprise-chat
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: lansenger-sdk>=1.0.1
+Requires-Dist: typer>=0.9
+Requires-Dist: rich>=13
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file

lansenger_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+lansenger_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lansenger_cli/main.py,sha256=m_xplXuUWJvtMFp3JTASTPPuPk4Q7fgWcCwd7E88GQI,1422
+lansenger_cli/utils.py,sha256=uGZmNzCCmEx65ll-4zCfev4OKdrgXiYG6gvT5RihWXM,2676
+lansenger_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lansenger_cli/commands/calendar.py,sha256=gxvRKOl-DOenLXjfcTSbeJW8jxC0GisfRx34wWmM8SI,6583
+lansenger_cli/commands/callback.py,sha256=vONZogM00ufA5ktxzw-jIiy_0R4FuKjnN_-vVNQR0Ro,2572
+lansenger_cli/commands/config.py,sha256=pcnYCO3TbinGBE6blCNLibokK7J-Bi1JUABGj8xhe40,1683
+lansenger_cli/commands/department.py,sha256=Evyhb1VTeCcCz-NM_V8g4w6wSIoEmO1irj6aKQjE8kg,2306
+lansenger_cli/commands/group.py,sha256=RE4rS6IdRF3EVM0kur8vJz7nenN8E2YDTkZH5zdc7GI,4930
+lansenger_cli/commands/health.py,sha256=P3-yZRqbMAeq0vWDDy_aGxz-__ha8LB1_u2tUvzbrtg,511
+lansenger_cli/commands/media.py,sha256=tY7i8JiOLzlv5m5CLFF0Xy822W4mRV5eLWOrV_WQqgg,1477
+lansenger_cli/commands/message.py,sha256=NprCYSciVL_ZpQXSwuzWw3v8GeSlXep5k7xC0iDp9MU,7090
+lansenger_cli/commands/oauth.py,sha256=HAe74GRc1SJHXcIj3qjKSvpikO4YpNK8Vpn7gN2PGRM,2603
+lansenger_cli/commands/staff.py,sha256=lPOWtcgTp73BqqbuLa5kFKqwPnR3BSnvCJPHVWyJCyY,4083
+lansenger_cli/commands/streaming.py,sha256=OJpEHlNfdOOmQVwY8KrXHtJAQLxZ2V5qB-a7nOv1KwE,972
+lansenger_cli/commands/todo.py,sha256=FERpN4IH4tw-_SpljhEU5QMTQoiHdqUiV1WwkN6HWL4,9017
+lansenger_cli-0.1.0.dist-info/licenses/LICENSE,sha256=34BiAEjSD1EejpdCkHjFTvIzyLpIGVCvWlD1dyUFPzk,1073
+lansenger_cli-0.1.0.dist-info/METADATA,sha256=QFwSPciEhEcUqwLpfsUuTAEqrDLeYSuyTmdADBjSfMo,836
+lansenger_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lansenger_cli-0.1.0.dist-info/entry_points.txt,sha256=Wl0YcBzsfQOnfB5j_5joUSDIWSzE7U86scMaUeTnopQ,53
+lansenger_cli-0.1.0.dist-info/top_level.txt,sha256=2hKVxWtjVnynROfgDw9VIkkSBOkXh-Fht3cUxfJrYuY,14
+lansenger_cli-0.1.0.dist-info/RECORD,,

lansenger_cli-0.1.0.dist-info/WHEEL

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

lansenger_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lansenger = lansenger_cli.main:app

lansenger_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lansenger PM Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lansenger_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lansenger_cli