hivespace 0.1.0__py3-none-any.whl

hivespace/__init__.py

@@ -0,0 +1 @@
+# hivespace package marker

hivespace/cli/app.py

@@ -0,0 +1,73 @@
+import json as json_mod
+from typing import Annotated, Optional
+
+import click
+import typer
+
+from hivespace.cli.state import set_json_mode
+from hivespace.cli.cmd_auth import auth_app
+from hivespace.cli.cmd_artifact import artifact_app
+from hivespace.cli.cmd_chat import chat_app
+from hivespace.cli.cmd_inbox import inbox_app
+from hivespace.cli.cmd_team import team_app
+from hivespace.cli.cmd_tasks import task_app
+from hivespace.cli.cmd_workflow import workflow_app
+from hivespace.cli.cmd_fs import fs_app
+
+app = typer.Typer(
+    name="hivespace",
+    rich_markup_mode="rich",
+    context_settings={"max_content_width": 120},
+    no_args_is_help=False,
+)
+
+
+def _version_callback(value: bool):
+    if value:
+        from importlib.metadata import version
+        click.echo(f"hivespace {version('hivespace')}")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: Annotated[Optional[bool], typer.Option(
+        "--version", "-v", help="Show version", callback=_version_callback, is_eager=True,
+    )] = None,
+):
+    """Hivespace — multi-agent workspace CLI."""
+    set_json_mode(False)
+    if ctx.invoked_subcommand is None:
+        from hivespace.cli.banner import print_banner
+        print_banner()
+
+
+app.add_typer(auth_app, name="auth", help="Sign in with a personal access token.")
+app.add_typer(chat_app, name="chat", help="Send and read messages.")
+app.add_typer(artifact_app, name="artifact", help="Link artifacts to this chat.")
+app.add_typer(inbox_app, name="inbox", help="View and manage @-mentions.")
+app.add_typer(team_app, name="team", help="Team info and agents.")
+app.add_typer(task_app, name="task", help="Create and manage tasks.")
+app.add_typer(workflow_app, name="workflow", help="Create, manage, suggest, and report on workflows (each runs in its own dedicated agent).")
+app.add_typer(fs_app, name="fs", help="Shared team drive (ls/cat/write/edit/cp).")
+
+_base_cli = typer.main.get_command(app)
+
+
+class HivespaceGroup(type(_base_cli)):
+    def invoke(self, ctx):
+        try:
+            return super().invoke(ctx)
+        except click.ClickException as e:
+            from hivespace.cli.state import is_json_mode
+            if is_json_mode():
+                click.echo(json_mod.dumps({"error": e.format_message()}))
+                ctx.exit(e.exit_code)
+            else:
+                raise
+
+
+cli = _base_cli
+cli.__class__ = HivespaceGroup
+cli.help = "Hivespace — multi-agent workspace CLI."

hivespace/cli/banner.py

@@ -0,0 +1,28 @@
+from hivespace.cli.console import get_console
+
+WORDMARK = r"""
+ ██╗  ██╗██╗██╗   ██╗███████╗███████╗██████╗  █████╗  ██████╗███████╗
+ ██║  ██║██║██║   ██║██╔════╝██╔════╝██╔══██╗██╔══██╗██╔════╝██╔════╝
+ ███████║██║██║   ██║█████╗  ███████╗██████╔╝███████║██║     █████╗
+ ██╔══██║██║╚██╗ ██╔╝██╔══╝  ╚════██║██╔═══╝ ██╔══██║██║     ██╔══╝
+ ██║  ██║██║ ╚████╔╝ ███████╗███████║██║     ██║  ██║╚██████╗███████╗
+ ╚═╝  ╚═╝╚═╝  ╚═══╝  ╚══════╝╚══════╝╚═╝     ╚═╝  ╚═╝ ╚═════╝╚══════╝
+"""
+
+COMMANDS_SUMMARY = """\
+[bold]Commands:[/bold]
+  [#e68a00]auth[/#e68a00]        Authentication and identity
+  [#e68a00]team[/#e68a00]        Team info and agents
+  [#e68a00]chat[/#e68a00]        Send and read messages
+  [#e68a00]task[/#e68a00]        Create and manage tasks
+  [#e68a00]inbox[/#e68a00]       View @-mentions
+  [#e68a00]fs[/#e68a00]          Shared team drive (ls/cat/write/edit/cp)
+
+[dim]Run 'hivespace <command> --help' for details on any command.[/dim]"""
+
+
+def print_banner() -> None:
+    console = get_console()
+    console.print(WORDMARK, style="bold #e68a00", highlight=False)
+    console.print("[dim]Multi-human, multi-agent teamspace[/dim]\n")
+    console.print(COMMANDS_SUMMARY)

hivespace/cli/cmd_artifact.py

@@ -0,0 +1,37 @@
+from typing import Annotated
+
+import typer
+
+from hivespace.cli.formatting import ok
+from hivespace.cli.helpers import _api, _json_out, _resolve_team
+from hivespace.cli.state import DeprecatedWorkspaceOpt, JsonFlag, TeamOpt, _set_team
+
+artifact_app = typer.Typer(no_args_is_help=True)
+
+
+@artifact_app.callback()
+def artifact_callback(team_opt: TeamOpt = None, workspace_opt: DeprecatedWorkspaceOpt = None):
+    """Artifacts — rendered webapps under the team's .artifact/ folder."""
+    _set_team(team_opt)
+
+
+@artifact_app.command("link")
+def artifact_link(
+    name: Annotated[str, typer.Argument(help="Artifact folder name under .artifact/")],
+    as_json: JsonFlag = False,
+    team_opt: TeamOpt = None,
+    workspace_opt: DeprecatedWorkspaceOpt = None,
+):
+    """Link an artifact to this chat.
+
+    Run this after writing/updating ``.artifact/<name>/`` so the artifact
+    surfaces as this chat's default in the preview panel. Safe to re-run —
+    it just refreshes the link.
+    """
+    team = _resolve_team(team_opt)
+    data = _api("POST", f"/teams/{team}/artifacts/{name}/link")
+    if as_json:
+        _json_out(data)
+    else:
+        url = data.get("external_url")
+        ok(f"team:{team}  artifact={data.get('name', name)}" + (f"  {url}" if url else ""))

hivespace/cli/cmd_auth.py

@@ -0,0 +1,108 @@
+"""hivespace auth — sign a local session in with a personal access token.
+
+PATs are minted in the web UI (scoped to a team, read or read/write) and
+pasted here. ``login`` validates and stores the token; the CLI then talks
+to the server as your user (``Authorization: Bearer``) instead of as an
+agent. ``whoami`` shows what the token can reach; ``logout`` clears it.
+
+    hivespace auth login [TOKEN]    # arg, prompt, or piped stdin
+    hivespace auth whoami
+    hivespace auth logout
+"""
+import sys
+from typing import Annotated, Optional
+
+import click
+import typer
+
+from hivespace.cli.formatting import ok
+from hivespace.cli.helpers import _api, _config, _json_out, _server_url, _set_auth, _set_server_url
+from hivespace.cli.state import JsonFlag, is_json_mode
+
+auth_app = typer.Typer(no_args_is_help=True)
+
+
+def _scope_label(me: dict) -> str:
+    teams = ", ".join(t["slug"] for t in me.get("teams", [])) or "(no team)"
+    level = "read/write" if me.get("can_write") else "read-only"
+    return f"team {teams} — {level}"
+
+
+@auth_app.command("login")
+def auth_login(
+    token: Annotated[Optional[str], typer.Argument(help="PAT (omit to paste/pipe)")] = None,
+    as_json: JsonFlag = False,
+):
+    """Store a personal access token for this machine.
+
+    The token is validated against the server before it's saved. Pass it
+    as an argument, pipe it on stdin, or omit it to be prompted (hidden).
+    """
+    if token is None:
+        if not sys.stdin.isatty():
+            token = sys.stdin.read().strip()
+        else:
+            token = click.prompt("Paste your token", hide_input=True).strip()
+    token = (token or "").strip()
+    if not token:
+        raise click.ClickException("no token provided")
+
+    server = _server_url()
+    # Validate by identifying ourselves; this also fetches the scope to
+    # show. Pass the token explicitly so we don't depend on it being saved.
+    me = _api("GET", "/me", headers={"Authorization": f"Bearer {token}"})
+    if not me.get("is_pat"):
+        raise click.ClickException("that token is not a personal access token")
+
+    _set_auth({
+        "token": token,
+        "prefix": token[:12],
+        "label": _scope_label(me),
+        "server_url": server.rstrip("/"),
+    })
+    # Pin the CLI to this server too, so later shells resolve the same host
+    # without HIVESPACE_SERVER set — otherwise _active_pat() drops the token
+    # on a server mismatch and you'd have to log in again.
+    _set_server_url(server)
+
+    if as_json:
+        _json_out({"ok": True, **me})
+        return
+    user = me.get("user") or {}
+    who = user.get("handle") or user.get("email") or "you"
+    ok(f"authenticated as {who} — {_scope_label(me)}")
+
+
+@auth_app.command("whoami")
+def auth_whoami(as_json: JsonFlag = False):
+    """Show the current identity and what the stored token can reach."""
+    me = _api("GET", "/me")
+    if as_json:
+        _json_out(me)
+        return
+    if me.get("kind") == "agent":
+        # An agent's identity is the agent itself, not its owner user.
+        a = me.get("agent") or {}
+        who = a.get("name") or (f"agent#{a['id']}" if a.get("id") else "(agent)")
+        mode = "agent"
+    else:
+        user = me.get("user") or {}
+        who = user.get("handle") or user.get("email") or "(unknown)"
+        mode = "PAT" if me.get("is_pat") else me.get("kind", "?")
+    click.echo(f"{who}  [{mode}]  {_scope_label(me)}")
+    teams = me.get("teams", [])
+    if teams:
+        click.echo("in-scope teams:")
+        for t in teams:
+            click.echo(f"  --team {t['slug']}  {t.get('name', '')}")
+
+
+@auth_app.command("logout")
+def auth_logout():
+    """Forget the stored token (reverts to agent-token mode if configured)."""
+    had = bool((_config().get("auth") or {}).get("token"))
+    _set_auth(None)
+    if is_json_mode():
+        _json_out({"ok": True, "was_logged_in": had})
+        return
+    ok("logged out" if had else "no token was stored")

hivespace/cli/cmd_chat.py

@@ -0,0 +1,72 @@
+from typing import Annotated, Optional
+
+import typer
+
+from hivespace.cli.components.chat import print_history, print_thread
+from hivespace.cli.formatting import ok
+from hivespace.cli.helpers import _api, _json_out, _resolve_team
+from hivespace.cli.state import DeprecatedWorkspaceOpt, JsonFlag, TeamOpt, _set_team
+
+chat_app = typer.Typer(no_args_is_help=True)
+
+
+@chat_app.callback()
+def chat_callback(team_opt: TeamOpt = None, workspace_opt: DeprecatedWorkspaceOpt = None):
+    """Chat — the team's Group Chat: messages and threads."""
+    _set_team(team_opt)
+
+
+@chat_app.command("send")
+def chat_send(
+    text: Annotated[str, typer.Argument(help="Message text")],
+    thread: Annotated[Optional[str], typer.Option("--thread", "-t", help="Reply to a message ts")] = None,
+    as_json: JsonFlag = False,
+    team_opt: TeamOpt = None,
+    workspace_opt: DeprecatedWorkspaceOpt = None,
+):
+    """Post a message to the team's Group Chat."""
+    team = _resolve_team(team_opt)
+    payload: dict = {"text": text}
+    if thread:
+        payload["thread_ts"] = thread
+    data = _api("POST", f"/teams/{team}/messages", json=payload)
+    if as_json:
+        _json_out(data)
+    else:
+        ok(f"team:{team}  ts={data.get('ts')}")
+
+
+@chat_app.command("history")
+def chat_history(
+    limit: Annotated[int, typer.Option("--limit", "-n", help="Max messages")] = 50,
+    before: Annotated[Optional[str], typer.Option("--before", help="Cursor: ts to page back from")] = None,
+    as_json: JsonFlag = False,
+    team_opt: TeamOpt = None,
+    workspace_opt: DeprecatedWorkspaceOpt = None,
+):
+    """Read recent messages in the team's Group Chat."""
+    team = _resolve_team(team_opt)
+    params: dict = {"limit": limit}
+    if before:
+        params["before"] = before
+    data = _api("GET", f"/teams/{team}/messages", params=params)
+    if as_json:
+        _json_out(data)
+        return
+    print_history(f"team:{team}", data.get("messages", []))
+
+
+@chat_app.command("thread")
+def chat_thread(
+    ts: Annotated[str, typer.Argument(help="Parent message ts")],
+    as_json: JsonFlag = False,
+    team_opt: TeamOpt = None,
+    workspace_opt: DeprecatedWorkspaceOpt = None,
+):
+    """Show a thread (parent message and replies)."""
+    team = _resolve_team(team_opt)
+    data = _api("GET", f"/teams/{team}/messages/{ts}/replies")
+    if as_json:
+        _json_out(data)
+        return
+    print_thread(f"team:{team}", data.get("parent", {}), data.get("replies", []))

hivespace/cli/cmd_fs.py

@@ -0,0 +1,247 @@
+"""hivespace fs — the shared team drive (Dropbox-style, CLI-only).
+
+Every agent in a team reads/writes one shared filesystem, namespaced
+server-side by ``team/<team_id>/``. The team is inferred from the agent
+token, so no ``--workspace`` is needed. Drive paths are written relative
+to the drive root (``reports/q1.csv``); ``cp`` marks the drive side with
+an ``drive:`` scheme so it can tell a drive path from a local sandbox
+path.
+
+    hivespace fs ls [path]
+    hivespace fs cat <path>
+    hivespace fs write <path> [content] [--from <local>]
+    hivespace fs edit <path> --old <s> --new <s> [--all]
+    hivespace fs mkdir <path>
+    hivespace fs mv <src> <dst>
+    hivespace fs rm <path>
+    hivespace fs cp drive:/reports/a.csv ./a.csv     # download
+    hivespace fs cp ./a.csv drive:/reports/a.csv     # upload
+"""
+import sys
+from pathlib import Path
+from typing import Annotated, Optional
+
+import click
+import typer
+
+from hivespace.cli.formatting import empty, ok
+from hivespace.cli.helpers import _api, _api_bytes, _api_upload, _json_out
+from hivespace.cli.state import JsonFlag
+
+fs_app = typer.Typer(no_args_is_help=True)
+
+_SCHEME = "drive:"
+_team: Optional[str] = None
+
+
+@fs_app.callback()
+def fs_callback(
+    team: Annotated[Optional[str], typer.Option(
+        "--team", help="Team slug. Required for user/PAT sessions that "
+        "belong to more than one team; agents infer it from their token.",
+    )] = None,
+):
+    """Shared team drive."""
+    global _team
+    _team = team or None
+
+
+def _params(extra: Optional[dict] = None) -> dict:
+    """Merge the selected ``--team`` into a query-param dict."""
+    p = dict(extra or {})
+    if _team:
+        p["team"] = _team
+    return p
+
+
+def _is_drive(p: str) -> bool:
+    return p.startswith(_SCHEME)
+
+
+def _drive_rel(p: str) -> str:
+    """``drive:/reports/a.csv`` → ``reports/a.csv`` (drive-root-relative)."""
+    return p[len(_SCHEME):].lstrip("/")
+
+
+@fs_app.command("ls")
+def fs_ls(
+    path: Annotated[str, typer.Argument(help="Drive path to list (default: root)")] = "",
+    tree: Annotated[bool, typer.Option("--tree", "-R", help="Recursive listing")] = False,
+    as_json: JsonFlag = False,
+):
+    """List a directory on the shared drive. Output: ``d <name>`` / ``f <name>``."""
+    data = _api("GET", "/fs/tree", params=_params({"path": path} if path else None))
+    lines = [ln for ln in (data or {}).get("tree", "").split("\n") if ln]
+    if as_json:
+        _json_out({"path": path or "/", "tree": lines})
+        return
+    if tree:
+        if not lines:
+            empty("(empty)")
+            return
+        for ln in lines:
+            click.echo(ln)
+        return
+    # Collapse the relative subtree to immediate children.
+    children: dict[str, bool] = {}
+    for ln in lines:
+        first = ln.split("/", 1)[0].rstrip("/")
+        if not first:
+            continue
+        is_dir = ("/" in ln) or ln.endswith("/")
+        children[first] = children.get(first, False) or is_dir
+    if not children:
+        empty("(empty)")
+        return
+    for name in sorted(children):
+        click.echo(f"{'d' if children[name] else 'f'} {name}")
+
+
+@fs_app.command("cat")
+def fs_cat(
+    path: Annotated[str, typer.Argument(help="Drive path to read")],
+):
+    """Print a file from the shared drive to stdout."""
+    body = _api_bytes("GET", "/fs/raw", params=_params({"path": path}))
+    sys.stdout.buffer.write(body)
+    sys.stdout.flush()
+
+
+@fs_app.command("write")
+def fs_write(
+    path: Annotated[str, typer.Argument(help="Drive path to write")],
+    content: Annotated[Optional[str], typer.Argument(help="Content (else --from or stdin)")] = None,
+    from_file: Annotated[Optional[str], typer.Option("--from", help="Read content from a local file")] = None,
+    as_json: JsonFlag = False,
+):
+    """Create or overwrite a whole file on the shared drive.
+
+    Content comes from the positional arg, else ``--from <local>``, else stdin.
+    """
+    if from_file is not None:
+        try:
+            data = Path(from_file).read_text()
+        except OSError as e:
+            raise click.ClickException(f"--from: {e}")
+    elif content is not None:
+        data = content
+    else:
+        data = sys.stdin.read()
+    _api("POST", "/fs/edit", params=_params(), json={"path": path, "content": data})
+    if as_json:
+        _json_out({"ok": True, "path": path, "bytes": len(data.encode("utf-8"))})
+        return
+    ok(f"wrote {path} ({len(data.encode('utf-8'))} bytes)")
+
+
+@fs_app.command("edit")
+def fs_edit(
+    path: Annotated[str, typer.Argument(help="Drive path to edit")],
+    old: Annotated[str, typer.Option("--old", help="String to find")],
+    new: Annotated[str, typer.Option("--new", help="Replacement string")],
+    replace_all: Annotated[bool, typer.Option("--all", help="Replace every occurrence")] = False,
+    as_json: JsonFlag = False,
+):
+    """In-place find/replace in a file on the shared drive."""
+    _api("POST", "/fs/edit", params=_params(), json={
+        "path": path, "old_string": old, "new_string": new, "replace_all": replace_all,
+    })
+    if as_json:
+        _json_out({"ok": True, "path": path})
+        return
+    ok(f"edited {path}")
+
+
+@fs_app.command("mkdir")
+def fs_mkdir(
+    path: Annotated[str, typer.Argument(help="Drive directory to create")],
+    as_json: JsonFlag = False,
+):
+    """Create a directory on the shared drive."""
+    _api("POST", "/fs/mkdir", params=_params(), json={"path": path})
+    if as_json:
+        _json_out({"ok": True, "path": path})
+        return
+    ok(f"created {path}")
+
+
+@fs_app.command("mv")
+def fs_mv(
+    src: Annotated[str, typer.Argument(help="Drive path to move")],
+    dst: Annotated[str, typer.Argument(help="New drive path")],
+    as_json: JsonFlag = False,
+):
+    """Move/rename a file or directory on the shared drive."""
+    _api("POST", "/fs/rename", params=_params(), json={"path": src, "new_path": dst})
+    if as_json:
+        _json_out({"ok": True, "path": src, "new_path": dst})
+        return
+    ok(f"{src} → {dst}")
+
+
+@fs_app.command("rm")
+def fs_rm(
+    path: Annotated[str, typer.Argument(help="Drive path to delete")],
+    as_json: JsonFlag = False,
+):
+    """Delete a file or directory on the shared drive."""
+    _api("POST", "/fs/delete", params=_params(), json={"path": path})
+    if as_json:
+        _json_out({"ok": True, "path": path})
+        return
+    ok(f"deleted {path}")
+
+
+@fs_app.command("cp")
+def fs_cp(
+    src: Annotated[str, typer.Argument(help="Source (drive:/path or local path)")],
+    dst: Annotated[str, typer.Argument(help="Destination (drive:/path or local path)")],
+    as_json: JsonFlag = False,
+):
+    """Copy between the shared drive and the local sandbox.
+
+    Mark the drive side with the ``drive:`` scheme:
+      cp drive:/reports/a.csv ./a.csv   (download)
+      cp ./a.csv drive:/reports/a.csv   (upload)
+    """
+    src_drive, dst_drive = _is_drive(src), _is_drive(dst)
+    if src_drive and dst_drive:
+        raise click.ClickException("drive-to-drive copy is not supported; one side must be local")
+    if not src_drive and not dst_drive:
+        raise click.ClickException("nothing to do: use plain 'cp' for local-to-local")
+
+    if src_drive:
+        # Download: drive → local sandbox.
+        remote = _drive_rel(src)
+        body = _api_bytes("GET", "/fs/raw", params=_params({"path": remote}))
+        target = Path(dst)
+        if dst.endswith("/") or target.is_dir():
+            target = target / remote.rsplit("/", 1)[-1]
+        if target.parent and not target.parent.exists():
+            target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes(body)
+        if as_json:
+            _json_out({"ok": True, "downloaded": str(target), "bytes": len(body)})
+        else:
+            ok(f"{src} → {target} ({len(body)} bytes)")
+        return
+
+    # Upload: local sandbox → drive.
+    local = Path(src)
+    if not local.is_file():
+        raise click.ClickException(f"local file not found: {src}")
+    remote = _drive_rel(dst)
+    if remote == "" or remote.endswith("/"):
+        directory = remote.rstrip("/")
+        filename = local.name
+    else:
+        directory, _, filename = remote.rpartition("/")
+        if not filename:
+            raise click.ClickException(f"invalid drive destination: {dst}")
+    content = local.read_bytes()
+    _api_upload("/fs/upload", directory=directory, filename=filename, content=content, params=_params())
+    final = f"{directory + '/' if directory else ''}{filename}"
+    if as_json:
+        _json_out({"ok": True, "uploaded": final, "bytes": len(content)})
+    else:
+        ok(f"{src} → drive:/{final} ({len(content)} bytes)")

hivespace/cli/cmd_inbox.py

@@ -0,0 +1,65 @@
+from typing import Annotated, Optional
+
+import click
+import typer
+
+from hivespace.cli.formatting import ok, relative_time
+from hivespace.cli.helpers import _api, _json_out, _resolve_team
+from hivespace.cli.state import DeprecatedWorkspaceOpt, JsonFlag, TeamOpt, _set_team
+
+inbox_app = typer.Typer(no_args_is_help=True)
+
+
+def _print_inbox(mentions: list[dict], unread_count: int) -> None:
+    if not mentions:
+        click.echo("No mentions.")
+        return
+    click.echo(f"{unread_count} unread")
+    for m in mentions:
+        author = (m.get("author") or {}).get("display") or "?"
+        ts = m.get("created_at", "")
+        text = m.get("text", "")
+        click.echo(f"  [{relative_time(ts)}] @{author}: {text}")
+
+
+@inbox_app.callback()
+def inbox_callback(team_opt: TeamOpt = None, workspace_opt: DeprecatedWorkspaceOpt = None):
+    """Inbox — view and manage @-mentions."""
+    _set_team(team_opt)
+
+
+@inbox_app.command("list")
+def inbox_list(
+    status: Annotated[str, typer.Option("--status", "-s", help="unread, read, or all")] = "unread",
+    limit: Annotated[int, typer.Option("--limit", "-n", help="Max mentions")] = 50,
+    before: Annotated[Optional[str], typer.Option("--before", help="Cursor: ts to page back from")] = None,
+    as_json: JsonFlag = False,
+    team_opt: TeamOpt = None,
+    workspace_opt: DeprecatedWorkspaceOpt = None,
+):
+    """List @-mentions of the current agent."""
+    team = _resolve_team(team_opt)
+    params: dict = {"status": status, "limit": limit}
+    if before:
+        params["before"] = before
+    data = _api("GET", f"/teams/{team}/inbox", params=params)
+    if as_json:
+        _json_out(data)
+        return
+    _print_inbox(data.get("mentions", []), data.get("unread_count", 0))
+
+
+@inbox_app.command("read")
+def inbox_read(
+    ts: Annotated[str, typer.Argument(help="Mark mentions up to this ts as read")],
+    as_json: JsonFlag = False,
+    team_opt: TeamOpt = None,
+    workspace_opt: DeprecatedWorkspaceOpt = None,
+):
+    """Mark mentions as read up to a given timestamp."""
+    team = _resolve_team(team_opt)
+    data = _api("POST", f"/teams/{team}/inbox/read", json={"ts": ts})
+    if as_json:
+        _json_out(data)
+    else:
+        ok(f"Marked as read up to ts={ts}")