pushmetrics-cli 0.1.0__py3-none-any.whl

pm/commands/users.py

@@ -0,0 +1,262 @@
+"""User commands."""
+from __future__ import annotations
+
+from typing import Optional
+
+import click
+
+from pm._alias import AliasedGroup
+from pm.client import PMClient
+from pm.commands._helpers import json_option, peek_name, yes_option, limit_option, name_filter_option, select_rows
+from pm.output import emit
+
+
+# pm-tool: REST-aligned verbs are canonical; legacy `add`/`remove`/`ls` keep
+# working as compatibility aliases so existing scripts don't break.
+@click.group(
+    name="users",
+    cls=AliasedGroup,
+    aliases={
+        # legacy → canonical: old form keeps working, canonical is primary
+        "ls": "list",
+        "add": "create",
+        "remove": "delete",
+    },
+)
+def users() -> None:
+    """Users in the current workspace."""
+
+
+def _role_name(role) -> str:
+    if role is None:
+        return ""
+    if hasattr(role, "model_dump"):
+        role = role.model_dump()
+    if isinstance(role, dict):
+        return role.get("name") or str(role.get("id", ""))
+    return str(role)
+
+
+def _format_roles(roles) -> str:
+    if not roles:
+        return ""
+    return ", ".join(_role_name(r) for r in roles)
+
+
+@users.command(name="list")
+@name_filter_option(matches="email, first or last name")
+@limit_option
+@json_option
+@click.pass_context
+def ls(ctx: click.Context, name_filter: Optional[str], limit: Optional[int]) -> None:
+    """List users in the current workspace."""
+    profile = ctx.obj["profile"]
+    json_output = ctx.obj["json"]
+
+    client = PMClient.from_profile(profile)
+    items = select_rows(
+        client.users.list(),
+        name=name_filter,
+        fields=("email", "first_name", "last_name"),
+        limit=limit,
+    )
+    client.persist()
+
+    emit(
+        items,
+        json_output=json_output,
+        columns=[
+            ("UID", "uid"),
+            ("EMAIL", "email"),
+            ("FIRST", "first_name"),
+            ("LAST", "last_name"),
+            ("MAIN_ROLE", lambda r: _role_name(r.get("main_role"))),
+            ("ROLES", lambda r: _format_roles(r.get("roles"))),
+            ("LAST_LOGIN", "last_login"),
+        ],
+    )
+
+
+@users.command(name="create")
+@click.argument("email")
+@click.option("--first-name", default="", help="First name.")
+@click.option("--last-name", default="", help="Last name.")
+@click.option(
+    "--role-id",
+    "role_ids",
+    type=int,
+    multiple=True,
+    help=(
+        "Numeric role id to assign (from pm role list). Without it the "
+        "workspace's default roles apply. Repeatable."
+    ),
+)
+@click.option(
+    "--skip-welcome-email",
+    is_flag=True,
+    help="Do not send the invitation email.",
+)
+@json_option
+@click.pass_context
+def add(
+    ctx: click.Context,
+    email: str,
+    first_name: str,
+    last_name: str,
+    role_ids: tuple,
+    skip_welcome_email: bool,
+) -> None:
+    """Invite a user to the current workspace.
+
+    An existing user of the organization is added to the workspace; a
+    new address gets an account and a welcome email (unless
+    --skip-welcome-email).
+    """
+    profile = ctx.obj["profile"]
+    json_output = ctx.obj["json"]
+
+    payload = {
+        "email": email,
+        "first_name": first_name,
+        "last_name": last_name,
+        "roles": list(role_ids),
+    }
+
+    client = PMClient.from_profile(profile)
+    user, action = client.users.create(payload, skip_welcome_email=skip_welcome_email)
+    client.persist()
+
+    if json_output:
+        out = user.model_dump()
+        if action is not None:
+            out["action"] = action
+        emit(out, json_output=True)
+        return
+
+    # Map the backend's action to a clear one-line outcome so callers
+    # don't have to compare workspace member lists themselves.
+    label = {
+        "created": "created",
+        "added_to_workspace": "added existing user to workspace",
+        "no_op": "already in this workspace (no change)",
+    }.get(action or "", "ok")
+    click.echo(f"{label}: {user.uid}  {user.email}  roles={_format_roles(user.roles)}")
+
+
+@users.command(name="delete")
+@click.argument("user_uid")
+@click.option(
+    "--workspace",
+    "workspace_uid",
+    default=None,
+    help="Workspace uid to remove the user from (default: the active workspace).",
+)
+@yes_option
+@json_option
+@click.pass_context
+def remove(
+    ctx: click.Context,
+    user_uid: str,
+    workspace_uid: Optional[str],
+    yes: bool,
+) -> None:
+    """Remove a user from a workspace.
+
+    The user loses their roles in that workspace. If it was their last
+    workspace, the account is deactivated, removed from the organization
+    and its email anonymised. This is the way to offboard a user.
+    """
+    profile = ctx.obj["profile"]
+    json_output = ctx.obj["json"]
+
+    if not yes:
+        label = peek_name(
+            lambda: PMClient.from_profile(profile).users.get(user_uid), "email"
+        ) or user_uid
+        target = f"workspace {workspace_uid}" if workspace_uid else "the active workspace"
+        click.confirm(
+            f"Remove user {label!r} from {target}? "
+            "If this is their last workspace they will be deactivated.",
+            abort=True,
+        )
+
+    client = PMClient.from_profile(profile)
+    client.users.remove_from_workspace(user_uid, workspace_uid)
+    client.persist()
+
+    if json_output:
+        emit(
+            {
+                "removed_user": user_uid,
+                "workspace": workspace_uid or "active",
+            },
+            json_output=True,
+        )
+        return
+    click.echo(f"Removed user {user_uid} from {workspace_uid or 'the active workspace'}.", err=True)
+
+
+@users.command(name="set-role")
+@click.argument("user_uid")
+@click.argument("main_role", type=click.Choice(["admin", "user", "guest"], case_sensitive=False))
+@json_option
+@click.pass_context
+def set_role(ctx: click.Context, user_uid: str, main_role: str) -> None:
+    """Set a user's main role in the current workspace.
+
+    Replaces the current main role; group memberships are unchanged.
+    """
+    profile = ctx.obj["profile"]
+    json_output = ctx.obj["json"]
+
+    client = PMClient.from_profile(profile)
+    role_id = client.roles.find_main_role_id(main_role)
+    user = client.users.update(user_uid, {"main_role": role_id})
+    client.persist()
+
+    if json_output:
+        emit(user, json_output=True)
+        return
+    emit(
+        {
+            "uid": user.uid,
+            "email": user.email,
+            "main_role": _role_name(user.main_role),
+            "roles": _format_roles(user.roles),
+        },
+        json_output=False,
+    )
+
+
+@users.command(name="get")
+@click.argument("user_id", metavar="USER_REF")
+@json_option
+@click.pass_context
+def get(ctx: click.Context, user_id: str) -> None:
+    """Show one user (use --json for the full record).
+
+    USER_REF is the user's uid or numeric id.
+    """
+    profile = ctx.obj["profile"]
+    json_output = ctx.obj["json"]
+
+    client = PMClient.from_profile(profile)
+    user = client.users.get(user_id)
+    client.persist()
+
+    if json_output:
+        emit(user, json_output=True)
+    else:
+        emit(
+            {
+                "id": user.id,
+                "uid": user.uid,
+                "email": user.email,
+                "first_name": user.first_name,
+                "last_name": user.last_name,
+                "main_role": _role_name(user.main_role),
+                "roles": _format_roles(user.roles),
+                "last_login": user.last_login,
+            },
+            json_output=False,
+        )

pm/commands/webhooks.py

@@ -0,0 +1,132 @@
+"""Webhook commands (full CRUD).
+
+The backend JSON-stringifies `details`/`recipients`/`slack_recipients` on input;
+the client handles that. Pass these via `--data '<json>'` for structured input,
+or as plain strings via the explicit flags.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+import click
+
+from pm._alias import AliasedGroup
+from pm.client import PMClient
+from pm.commands._helpers import (
+    confirm_delete,
+    json_option,
+    merge_fields,
+    parse_data,
+    peek_name,
+    report_deleted,
+    yes_option,
+    limit_option,
+    select_rows,
+)
+from pm.output import emit
+
+
+@click.group(name="webhooks", cls=AliasedGroup, aliases={"ls": "list"})
+def webhooks() -> None:
+    """Webhooks that trigger report runs."""
+
+
+@webhooks.command(name="list")
+@limit_option
+@json_option
+@click.pass_context
+def ls(ctx: click.Context, limit: Optional[int]) -> None:
+    """List webhooks (ids only).
+
+    The list shows each webhook's numeric id; pm webhook get <id> shows
+    the rest.
+    """
+    client = PMClient.from_profile(ctx.obj["profile"])
+    items = select_rows(client.webhooks.list(), limit=limit)
+    client.persist()
+    emit(
+        items,
+        json_output=ctx.obj["json"],
+        # Only `id` is meaningful — other columns are null until backend adds list_columns.
+        columns=[("ID", "id")],
+    )
+
+
+@webhooks.command(name="get")
+@click.argument("uid")
+@json_option
+@click.pass_context
+def get(ctx: click.Context, uid: str) -> None:
+    """Show one webhook."""
+    client = PMClient.from_profile(ctx.obj["profile"])
+    wh = client.webhooks.get(uid)
+    client.persist()
+    emit(wh, json_output=ctx.obj["json"])
+
+
+@webhooks.command(name="create")
+@click.option("--report-id", type=int, required=True,
+              help="Numeric id of the report to trigger (from pm report get --json).")
+@click.option("--token", default=None,
+              help="Secret the caller must present. Generated if omitted.")
+@click.option("--active/--inactive", default=True, show_default=True,
+              help="Whether the webhook accepts calls.")
+@click.option("--data", default=None, help="Extra fields (details, recipients, slack_recipients) as a JSON object.")
+@json_option
+@click.pass_context
+def create(
+    ctx: click.Context,
+    report_id: int,
+    token: Optional[str],
+    active: bool,
+    data: Optional[str],
+) -> None:
+    """Create a webhook for a report."""
+    payload = merge_fields(
+        parse_data(data),
+        {"report_id": report_id, "token": token, "active": active},
+    )
+    client = PMClient.from_profile(ctx.obj["profile"])
+    wh = client.webhooks.create(payload)
+    client.persist()
+    emit(wh, json_output=ctx.obj["json"])
+
+
+@webhooks.command(name="update")
+@click.argument("uid")
+@click.option("--token", default=None, help="Replace the secret the caller must present.")
+@click.option("--active/--inactive", default=None, help="Enable or disable the webhook.")
+@click.option("--data", default=None, help="Extra fields as a JSON object.")
+@json_option
+@click.pass_context
+def update(
+    ctx: click.Context,
+    uid: str,
+    token: Optional[str],
+    active: Optional[bool],
+    data: Optional[str],
+) -> None:
+    """Update a webhook."""
+    payload = merge_fields(parse_data(data), {"token": token, "active": active})
+    if not payload:
+        raise click.UsageError("Nothing to update; pass --token, --active/--inactive, or --data.")
+    client = PMClient.from_profile(ctx.obj["profile"])
+    wh = client.webhooks.update(uid, payload)
+    client.persist()
+    emit(wh, json_output=ctx.obj["json"])
+
+
+@webhooks.command(name="delete")
+@click.argument("uid")
+@yes_option
+@json_option
+@click.pass_context
+def delete(ctx: click.Context, uid: str, yes: bool) -> None:
+    """Delete a webhook."""
+    if not yes:
+        name = peek_name(lambda: PMClient.from_profile(ctx.obj["profile"]).webhooks.get(uid), "name")
+        confirm_delete("webhook", uid, name)
+    client = PMClient.from_profile(ctx.obj["profile"])
+    client.webhooks.delete(uid)
+    client.persist()
+    report_deleted(ctx, "webhook", uid)

pm/commands/workspace.py

@@ -0,0 +1,156 @@
+"""Workspace commands."""
+from __future__ import annotations
+
+from typing import Optional
+
+import click
+
+from pm._alias import AliasedGroup
+from pm.client import PMClient
+from pm.commands._helpers import (
+    confirm_delete,
+    json_option,
+    peek_name,
+    report_deleted,
+    yes_option,
+    limit_option,
+    name_filter_option,
+    select_rows,
+)
+from pm.output import emit
+
+
+@click.group(name="workspace", cls=AliasedGroup, aliases={"ls": "list"})
+def workspace() -> None:
+    """Workspaces you belong to."""
+
+
+@workspace.command(name="list")
+@name_filter_option
+@limit_option
+@json_option
+@click.pass_context
+def ls(ctx: click.Context, name_filter: Optional[str], limit: Optional[int]) -> None:
+    """List workspaces you have access to."""
+    profile = ctx.obj["profile"]
+    json_output = ctx.obj["json"]
+
+    client = PMClient.from_profile(profile)
+    workspaces_list = select_rows(client.workspaces.list(), name=name_filter, limit=limit)
+    client.persist()
+
+    emit(
+        workspaces_list,
+        json_output=json_output,
+        columns=[
+            ("ACTIVE", lambda r: "*" if r.get("is_active") else ""),
+            ("UID", "uid"),
+            ("NAME", "name"),
+            ("ORGANIZATION", lambda r: (r.get("organization") or {}).get("name") if isinstance(r.get("organization"), dict) else None),
+        ],
+    )
+
+
+@workspace.command(name="current")
+@json_option
+@click.pass_context
+def current(ctx: click.Context) -> None:
+    """Show the active workspace."""
+    profile = ctx.obj["profile"]
+    json_output = ctx.obj["json"]
+
+    client = PMClient.from_profile(profile)
+    ws = client.workspaces.current()
+    client.persist()
+
+    emit(
+        {
+            "uid": ws.uid,
+            "name": ws.name,
+            "id": ws.id,
+        },
+        json_output=json_output,
+    )
+
+
+@workspace.command(name="switch")
+@click.argument("uid")
+@json_option
+@click.pass_context
+def switch(ctx: click.Context, uid: str) -> None:
+    """Switch the active workspace (browser login only).
+
+    Not available with a personal access token: a token is bound to the
+    workspace it was created in. To work in another workspace, create a
+    token there and run pm login --token with it.
+    """
+    profile = ctx.obj["profile"]
+    json_output = ctx.obj["json"]
+
+    client = PMClient.from_profile(profile)
+    ws = client.workspaces.switch(uid)
+
+    emit(
+        {
+            "switched_to": ws.name,
+            "uid": ws.uid,
+        },
+        json_output=json_output,
+    )
+
+
+@workspace.command(name="delete")
+@click.argument("uid")
+@yes_option
+@json_option
+@click.pass_context
+def delete(ctx: click.Context, uid: str, yes: bool) -> None:
+    """Delete a workspace and everything in it.
+
+    All reports, agents and roles in the workspace are removed. This
+    cannot be undone. You cannot delete the workspace you are working in,
+    or your only workspace.
+    """
+    profile = ctx.obj["profile"]
+
+    if not yes:
+        name = peek_name(lambda: PMClient.from_profile(profile).workspaces.get(uid), "name")
+        confirm_delete(
+            "workspace", uid, name,
+            note="All reports, agents and roles in it will be gone.",
+        )
+
+    client = PMClient.from_profile(profile)
+    client.workspaces.delete(uid)
+    client.persist()
+    report_deleted(ctx, "workspace", uid)
+
+
+@workspace.command(name="create")
+@click.argument("name")
+@json_option
+@click.pass_context
+def create(ctx: click.Context, name: str) -> None:
+    """Create a workspace in your organization.
+
+    You become its first member; it starts with the default roles and a
+    default agent.
+    """
+    profile = ctx.obj["profile"]
+    json_output = ctx.obj["json"]
+
+    client = PMClient.from_profile(profile)
+    ws = client.workspaces.create({"name": name})
+    client.persist()
+
+    if json_output:
+        emit(ws, json_output=True)
+        return
+    emit(
+        {
+            "uid": ws.uid,
+            "name": ws.name,
+            "id": ws.id,
+        },
+        json_output=False,
+    )