dailybot-cli 3.8.0__tar.gz → 3.9.0__tar.gz

{dailybot_cli-3.8.0 → dailybot_cli-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dailybot-cli
-Version: 3.8.0
+Version: 3.9.0
 Summary: Dailybot CLI - The command-line bridge between humans and agents. Progress reports, observability, and workflow automation for modern teams across Slack, Google Chat, Discord, MS Teams, and more.
 Author-email: Dailybot <support@dailybot.com>
 License: MIT

{dailybot_cli-3.8.0 → dailybot_cli-3.9.0}/dailybot_cli/api_client.py

@@ -106,6 +106,37 @@ def _merge_list_query(
     return params
 
 
+def _merge_dashboard_enrichment_query(
+    params: dict[str, Any],
+    *,
+    labels: list[str] | None = None,
+    featured: bool | None = None,
+    prioritize_featured: bool | None = None,
+) -> dict[str, Any]:
+    """Merge Labels / Featured dashboard enrichment query params."""
+    if labels:
+        params["labels"] = ",".join(labels)
+    if featured is not None:
+        params["featured"] = "true" if featured else "false"
+    if prioritize_featured is not None:
+        params["prioritize_featured"] = "true" if prioritize_featured else "false"
+    return params
+
+
+def _label_entity_collection(entity_type: str) -> str:
+    """Map CLI entity type (including web 'automations') to the public API path."""
+    normalized: str = entity_type.strip().lower()
+    if normalized in {"automations", "workflows", "workflow"}:
+        return "workflows"
+    if normalized in {"forms", "form"}:
+        return "forms"
+    if normalized in {"checkins", "checkin", "check-ins"}:
+        return "checkins"
+    raise ValueError(
+        f"entity type must be one of: forms, checkins, workflows (got {entity_type!r})"
+    )
+
+
 def _fill_meta(meta: dict[str, Any] | None, result: "PaginatedResult") -> None:
     """Populate a caller-provided meta dict with pagination totals, if given."""
     if meta is not None:
@@ -640,6 +671,9 @@ class DailyBotClient:
         fetch_all: bool = True,
         limit: int | None = None,
         meta: dict[str, Any] | None = None,
+        labels: list[str] | None = None,
+        featured: bool | None = None,
+        prioritize_featured: bool | None = None,
     ) -> list[dict[str, Any]]:
         """GET /v1/checkins/ — fetch visible check-ins with optional search/paging."""
         params: dict[str, Any] = {}
@@ -652,6 +686,12 @@ class DailyBotClient:
         if include_archived:
             params["include_archived"] = "true"
         _merge_list_query(params, search=search, start_date=start_date, end_date=end_date)
+        _merge_dashboard_enrichment_query(
+            params,
+            labels=labels,
+            featured=featured,
+            prioritize_featured=prioritize_featured,
+        )
         result: PaginatedResult = self._paginated_get(
             f"{self.api_url}/v1/checkins/",
             params=params,
@@ -963,6 +1003,9 @@ class DailyBotClient:
         fetch_all: bool = True,
         limit: int | None = None,
         meta: dict[str, Any] | None = None,
+        labels: list[str] | None = None,
+        featured: bool | None = None,
+        prioritize_featured: bool | None = None,
     ) -> list[dict[str, Any]]:
         """GET /v1/forms/ — optionally expand questions, search, and page.
 
@@ -990,6 +1033,12 @@ class DailyBotClient:
         if is_ascend:
             params["is_ascend"] = "true"
         _merge_list_query(params, search=search, start_date=start_date, end_date=end_date)
+        _merge_dashboard_enrichment_query(
+            params,
+            labels=labels,
+            featured=featured,
+            prioritize_featured=prioritize_featured,
+        )
         result: PaginatedResult = self._paginated_get(
             f"{self.api_url}/v1/forms/",
             params=params,
@@ -1442,10 +1491,19 @@ class DailyBotClient:
         fetch_all: bool = True,
         limit: int | None = None,
         meta: dict[str, Any] | None = None,
+        labels: list[str] | None = None,
+        featured: bool | None = None,
+        prioritize_featured: bool | None = None,
     ) -> list[dict[str, Any]]:
         """GET /v1/workflows/ — list workflows (plan-gated feature)."""
         params: dict[str, Any] = {}
         _merge_list_query(params, search=search, start_date=start_date, end_date=end_date)
+        _merge_dashboard_enrichment_query(
+            params,
+            labels=labels,
+            featured=featured,
+            prioritize_featured=prioritize_featured,
+        )
         result: PaginatedResult = self._paginated_get(
             f"{self.api_url}/v1/workflows/",
             params=params,
@@ -1789,6 +1847,157 @@ class DailyBotClient:
         )
         return self._handle_response(response)
 
+    # --- Organization Labels (/v1/labels/) ---
+
+    def get_labels_entitlement(self) -> dict[str, Any]:
+        """GET /v1/labels/entitlement/ — org Labels feature flags for the caller."""
+        response: httpx.Response = self._request("GET", f"{self.api_url}/v1/labels/entitlement/")
+        return self._handle_response(response)
+
+    def list_labels(
+        self,
+        *,
+        search: str | None = None,
+        is_archived: bool = False,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """GET /v1/labels/ — paginated org Labels (limit/offset)."""
+        params: dict[str, Any] = {
+            "limit": max(1, min(limit, 100)),
+            "offset": max(0, offset),
+            "is_archived": is_archived,
+        }
+        if search:
+            params["search"] = search
+        response: httpx.Response = self._request("GET", f"{self.api_url}/v1/labels/", params=params)
+        return self._handle_response(response)
+
+    def get_label(self, label_uuid: str) -> dict[str, Any]:
+        """GET /v1/labels/<uuid>/ — one organization Label."""
+        response: httpx.Response = self._request("GET", f"{self.api_url}/v1/labels/{label_uuid}/")
+        return self._handle_response(response)
+
+    def create_label(
+        self,
+        *,
+        name: str,
+        color: str | None = None,
+        description: str | None = None,
+    ) -> dict[str, Any]:
+        """POST /v1/labels/ — create an organization Label."""
+        body: dict[str, Any] = {"name": name}
+        if color is not None:
+            body["color"] = color
+        if description is not None:
+            body["description"] = description
+        response: httpx.Response = self._request("POST", f"{self.api_url}/v1/labels/", json=body)
+        return self._handle_response(response)
+
+    def update_label(self, label_uuid: str, body: dict[str, Any]) -> dict[str, Any]:
+        """PATCH /v1/labels/<uuid>/ — update an organization Label."""
+        response: httpx.Response = self._request(
+            "PATCH", f"{self.api_url}/v1/labels/{label_uuid}/", json=body
+        )
+        return self._handle_response(response)
+
+    def delete_label(self, label_uuid: str) -> None:
+        """DELETE /v1/labels/<uuid>/ — hard-delete (elevated only)."""
+        response: httpx.Response = self._request(
+            "DELETE", f"{self.api_url}/v1/labels/{label_uuid}/"
+        )
+        if response.status_code == 204:
+            return
+        self._handle_response(response)
+
+    def archive_label(self, label_uuid: str) -> dict[str, Any]:
+        """POST /v1/labels/<uuid>/archive/ — archive a Label."""
+        response: httpx.Response = self._request(
+            "POST", f"{self.api_url}/v1/labels/{label_uuid}/archive/"
+        )
+        return self._handle_response(response)
+
+    def assign_entity_labels(
+        self,
+        entity_type: str,
+        entity_uuid: str,
+        label_uuids: list[str],
+    ) -> dict[str, Any]:
+        """POST /v1/{forms|checkins|workflows}/{uuid}/labels/ — replace-set Labels."""
+        collection: str = _label_entity_collection(entity_type)
+        response: httpx.Response = self._request(
+            "POST",
+            f"{self.api_url}/v1/{collection}/{entity_uuid}/labels/",
+            json={"label_uuids": label_uuids},
+        )
+        return self._handle_response(response)
+
+    def batch_entity_labels(
+        self,
+        *,
+        entity_type: str,
+        entity_uuids: list[str],
+        label_uuids: list[str],
+        mode: str,
+    ) -> dict[str, Any]:
+        """POST /v1/{forms|checkins|workflows}/labels/batch/ — add/remove/replace."""
+        collection: str = _label_entity_collection(entity_type)
+        response: httpx.Response = self._request(
+            "POST",
+            f"{self.api_url}/v1/{collection}/labels/batch/",
+            json={
+                "entity_uuids": entity_uuids,
+                "label_uuids": label_uuids,
+                "mode": mode,
+            },
+        )
+        return self._handle_response(response)
+
+    # --- Private Featured stars (/v1/me/featured/) ---
+
+    def list_featured(self, *, entity_type: str) -> dict[str, Any]:
+        """GET /v1/me/featured/?entity_type= — list Featured entity UUIDs for the caller."""
+        response: httpx.Response = self._request(
+            "GET",
+            f"{self.api_url}/v1/me/featured/",
+            params={"entity_type": entity_type},
+        )
+        return self._handle_response(response)
+
+    def set_featured(
+        self,
+        entity_type: str,
+        entity_uuid: str,
+        *,
+        featured: bool,
+    ) -> dict[str, Any]:
+        """PUT /v1/me/featured/{entity_type}/{uuid}/ — toggle Featured for one entity."""
+        response: httpx.Response = self._request(
+            "PUT",
+            f"{self.api_url}/v1/me/featured/{entity_type}/{entity_uuid}/",
+            json={"featured": featured},
+        )
+        return self._handle_response(response)
+
+    def batch_featured(
+        self,
+        *,
+        entity_type: str,
+        entity_uuids: list[str],
+        featured: bool,
+    ) -> dict[str, Any]:
+        """POST /v1/me/featured/batch/ — batch feature/unfeature entities."""
+        response: httpx.Response = self._request(
+            "POST",
+            f"{self.api_url}/v1/me/featured/batch/",
+            json={
+                "entity_type": entity_type,
+                "entity_uuids": entity_uuids,
+                "featured": featured,
+            },
+        )
+        return self._handle_response(response)
+
     # --- Agent registration endpoints ---
 
     def get_registration_challenge(self) -> dict[str, Any]:

{dailybot_cli-3.8.0 → dailybot_cli-3.9.0}/dailybot_cli/commands/checkin.py

@@ -30,6 +30,7 @@ from dailybot_cli.commands.public_api_helpers import (
     emit_json,
     enforce_plan_access,
     exit_for_api_error,
+    normalize_checkin_entity_json,
     require_auth,
     validate_user_filter,
 )
@@ -524,7 +525,7 @@ def checkin_create(
         exit_for_api_error(exc, json_mode)
 
     if json_mode:
-        emit_json(result)
+        emit_json(normalize_checkin_entity_json(result))
         return
     print_checkin_created(result)
 
@@ -610,7 +611,7 @@ def checkin_config(
         exit_for_api_error(exc, json_mode)
 
     if json_mode:
-        emit_json(result)
+        emit_json(normalize_checkin_entity_json(result))
         return
     print_success(f"Check-in {followup_uuid} updated.")
     print_checkin_created(result, updated=True)

dailybot_cli-3.9.0/dailybot_cli/commands/featured.py

@@ -0,0 +1,147 @@
+"""Private Featured star commands (/v1/me/featured/)."""
+
+from typing import Any
+
+import click
+
+from dailybot_cli.api_client import APIError
+from dailybot_cli.commands.public_api_helpers import (
+    emit_json,
+    exit_for_api_error,
+    require_auth,
+)
+from dailybot_cli.display import console, print_featured_summary, print_success
+
+FEATURED_ENTITY_TYPES: tuple[str, ...] = ("forms", "automations", "checkins")
+
+
+def _parse_entity_type(ctx: click.Context, param: click.Parameter, value: str) -> str:
+    normalized: str = value.strip().lower()
+    if normalized not in FEATURED_ENTITY_TYPES:
+        raise click.BadParameter(f"entity_type must be one of: {', '.join(FEATURED_ENTITY_TYPES)}")
+    return normalized
+
+
+@click.group()
+def featured() -> None:
+    """Manage your private Featured stars on Forms, Automations, and Check-ins.
+
+    \b
+    Featured is per-user (not org-shared). Not gated by paid Labels.
+    """
+
+
+@featured.command("list")
+@click.option(
+    "--entity-type",
+    "entity_type",
+    required=True,
+    callback=_parse_entity_type,
+    help="Entity type: forms, automations, or checkins.",
+)
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def featured_list(entity_type: str, json_mode: bool) -> None:
+    """List Featured entity UUIDs for one entity type."""
+    client = require_auth()
+    try:
+        with console.status("Fetching featured items..."):
+            data: dict[str, Any] = client.list_featured(entity_type=entity_type)
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    print_featured_summary(data)
+
+
+@featured.command("set")
+@click.option(
+    "--entity-type",
+    "entity_type",
+    required=True,
+    callback=_parse_entity_type,
+    help="Entity type: forms, automations, or checkins.",
+)
+@click.argument("entity_uuid")
+@click.option(
+    "--featured/--unfeatured",
+    default=True,
+    help="Star (default) or unstar the entity.",
+)
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def featured_set(
+    entity_type: str,
+    entity_uuid: str,
+    featured: bool,
+    json_mode: bool,
+) -> None:
+    """Toggle Featured for one entity."""
+    client = require_auth()
+    try:
+        with console.status("Updating featured state..."):
+            data: dict[str, Any] = client.set_featured(
+                entity_type,
+                entity_uuid,
+                featured=featured,
+            )
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    state: str = "featured" if data.get("is_featured", featured) else "unfeatured"
+    print_success(f"Marked {entity_uuid} as {state} ({entity_type}).")
+
+
+@featured.command("batch")
+@click.option(
+    "--entity-type",
+    "entity_type",
+    required=True,
+    callback=_parse_entity_type,
+    help="Entity type: forms, automations, or checkins.",
+)
+@click.option(
+    "--uuids",
+    required=True,
+    help="Comma-separated entity UUIDs.",
+)
+@click.option(
+    "--featured/--unfeatured",
+    default=True,
+    help="Feature (default) or unfeature all listed entities.",
+)
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def featured_batch(
+    entity_type: str,
+    uuids: str,
+    featured: bool,
+    json_mode: bool,
+) -> None:
+    """Batch feature or unfeature multiple entities."""
+    entity_uuids: list[str] = [part.strip() for part in uuids.split(",") if part.strip()]
+    if not entity_uuids:
+        raise click.UsageError("--uuids must contain at least one UUID.")
+
+    client = require_auth()
+    try:
+        with console.status("Updating featured items..."):
+            data: dict[str, Any] = client.batch_featured(
+                entity_type=entity_type,
+                entity_uuids=entity_uuids,
+                featured=featured,
+            )
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    updated: int = len(data.get("updated_entity_uuids", entity_uuids))
+    state: str = "featured" if featured else "unfeatured"
+    print_success(f"Marked {updated} {entity_type} item(s) as {state}.")

dailybot_cli-3.9.0/dailybot_cli/commands/label.py

@@ -0,0 +1,404 @@
+"""Organization Labels commands (/v1/labels/)."""
+
+from typing import Any
+
+import click
+
+from dailybot_cli.api_client import APIError, DailyBotClient
+from dailybot_cli.commands.public_api_helpers import (
+    emit_json,
+    enforce_plan_access,
+    exit_for_api_error,
+    require_auth,
+)
+from dailybot_cli.display import (
+    console,
+    print_detail_panel,
+    print_label_assignment,
+    print_labels_table,
+    print_success,
+)
+
+_LABEL_ENTITY_TYPES: tuple[str, ...] = ("forms", "checkins", "workflows", "automations")
+_BATCH_MODES: tuple[str, ...] = ("add", "remove", "replace")
+
+
+def _parse_label_entity_type(_ctx: click.Context, _param: click.Parameter, value: str) -> str:
+    normalized: str = value.strip().lower()
+    if normalized not in _LABEL_ENTITY_TYPES:
+        raise click.BadParameter(
+            "must be one of: forms, checkins, workflows (automations is an alias)"
+        )
+    if normalized == "automations":
+        return "workflows"
+    return normalized
+
+
+def _parse_label_uuid_list(values: tuple[str, ...]) -> list[str]:
+    uuids: list[str] = []
+    for raw in values:
+        for part in raw.split(","):
+            token: str = part.strip()
+            if token:
+                uuids.append(token)
+    # Preserve order, drop duplicates.
+    return list(dict.fromkeys(uuids))
+
+
+_LABEL_FIELDS: list[tuple[str, str]] = [
+    ("Name", "name"),
+    ("UUID", "uuid"),
+    ("Color", "color"),
+    ("Description", "description"),
+    ("Archived", "is_archived"),
+    ("Usage (total)", "usage_total"),
+]
+
+
+def _usage_total(label: dict[str, Any]) -> dict[str, Any]:
+    usage: dict[str, Any] = label.get("usage") or {}
+    enriched: dict[str, Any] = dict(label)
+    enriched["usage_total"] = usage.get("total", 0)
+    return enriched
+
+
+@click.group()
+def label() -> None:
+    """Manage organization Labels (paid Feature.LABELS).
+
+    \b
+    Shared taxonomy for Forms, Automations, and Check-ins. Acts as you —
+    permissions match the web app (members create; elevated roles manage all).
+    """
+
+
+@label.command("entitlement")
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def label_entitlement(json_mode: bool) -> None:
+    """Show Labels entitlement flags for your org."""
+    enforce_plan_access("label_entitlement", json_mode=json_mode)
+    client = require_auth()
+    try:
+        with console.status("Checking Labels entitlement..."):
+            data: dict[str, Any] = client.get_labels_entitlement()
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    print_detail_panel(
+        "Labels entitlement",
+        data,
+        [
+            ("Entitled", "entitled"),
+            ("Can create", "can_create"),
+            ("Can manage all", "can_manage_all"),
+            ("Can hard delete", "can_hard_delete"),
+            ("Guest", "is_guest"),
+        ],
+    )
+
+
+@label.command("list")
+@click.option("--search", default=None, help="Case-insensitive name search.")
+@click.option("--archived", is_flag=True, help="Include archived Labels.")
+@click.option("--limit", default=20, type=click.IntRange(1, 100), show_default=True)
+@click.option("--offset", default=0, type=click.IntRange(0, 100000), show_default=True)
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def label_list(
+    search: str | None,
+    archived: bool,
+    limit: int,
+    offset: int,
+    json_mode: bool,
+) -> None:
+    """List organization Labels."""
+    enforce_plan_access("label_list", json_mode=json_mode)
+    client = require_auth()
+    try:
+        with console.status("Fetching labels..."):
+            data: dict[str, Any] = client.list_labels(
+                search=search,
+                is_archived=archived,
+                limit=limit,
+                offset=offset,
+            )
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    results: list[dict[str, Any]] = data.get("results", [])
+    print_labels_table(results)
+    count: int | None = data.get("count")
+    if count is not None:
+        console.print(f"[dim]{count} total[/dim]")
+
+
+@label.command("get")
+@click.argument("label_uuid")
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def label_get(label_uuid: str, json_mode: bool) -> None:
+    """Get one Label by UUID."""
+    enforce_plan_access("label_get", json_mode=json_mode)
+    client = require_auth()
+    try:
+        with console.status("Loading label..."):
+            data: dict[str, Any] = client.get_label(label_uuid)
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    print_detail_panel("Label", _usage_total(data), _LABEL_FIELDS)
+
+
+@label.command("create")
+@click.option("--name", required=True, help="Label name (unique per org).")
+@click.option("--color", default=None, help="Hex color (e.g. #4A90E2).")
+@click.option("--description", default=None, help="Optional description.")
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def label_create(
+    name: str,
+    color: str | None,
+    description: str | None,
+    json_mode: bool,
+) -> None:
+    """Create an organization Label."""
+    enforce_plan_access("label_create", json_mode=json_mode)
+    client = require_auth()
+    try:
+        with console.status("Creating label..."):
+            data: dict[str, Any] = client.create_label(
+                name=name,
+                color=color,
+                description=description,
+            )
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    print_success(f"Created label '{data.get('name', name)}' ({data.get('uuid', '')}).")
+
+
+@label.command("update")
+@click.argument("label_uuid")
+@click.option("--name", default=None, help="New name.")
+@click.option("--color", default=None, help="New hex color.")
+@click.option("--description", default=None, help="New description (empty string clears).")
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def label_update(
+    label_uuid: str,
+    name: str | None,
+    color: str | None,
+    description: str | None,
+    json_mode: bool,
+) -> None:
+    """Update an organization Label."""
+    enforce_plan_access("label_update", json_mode=json_mode)
+    body: dict[str, Any] = {}
+    if name is not None:
+        body["name"] = name
+    if color is not None:
+        body["color"] = color
+    if description is not None:
+        body["description"] = description
+    if not body:
+        raise click.UsageError("Pass at least one of --name, --color, or --description.")
+
+    client = require_auth()
+    try:
+        with console.status("Updating label..."):
+            data: dict[str, Any] = client.update_label(label_uuid, body)
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    print_success(f"Updated label '{data.get('name', label_uuid)}'.")
+
+
+@label.command("archive")
+@click.argument("label_uuid")
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def label_archive(label_uuid: str, json_mode: bool) -> None:
+    """Archive a Label (idempotent)."""
+    enforce_plan_access("label_archive", json_mode=json_mode)
+    client = require_auth()
+    try:
+        with console.status("Archiving label..."):
+            data: dict[str, Any] = client.archive_label(label_uuid)
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    print_success(f"Archived label '{data.get('name', label_uuid)}'.")
+
+
+@label.command("delete")
+@click.argument("label_uuid")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt.")
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def label_delete(label_uuid: str, yes: bool, json_mode: bool) -> None:
+    """Hard-delete a Label (elevated only; fails when in use)."""
+    enforce_plan_access("label_delete", json_mode=json_mode)
+    client: DailyBotClient = require_auth()
+
+    if (
+        not yes
+        and not json_mode
+        and not click.confirm(
+            f"Permanently delete label {label_uuid}? This cannot be undone.",
+            default=False,
+        )
+    ):
+        raise SystemExit(0)
+
+    try:
+        with console.status("Deleting label..."):
+            client.delete_label(label_uuid)
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json({"deleted": True, "uuid": label_uuid})
+        return
+
+    print_success(f"Deleted label {label_uuid}.")
+
+
+@label.command("assign")
+@click.argument("entity_uuid")
+@click.option(
+    "--type",
+    "entity_type",
+    required=True,
+    callback=_parse_label_entity_type,
+    help="Entity type: forms, checkins, or workflows (automations alias).",
+)
+@click.option(
+    "--label",
+    "label_refs",
+    multiple=True,
+    help="Label UUID to attach (repeatable, or comma-separated). Replace-set.",
+)
+@click.option(
+    "--clear",
+    is_flag=True,
+    help="Remove every Label from this entity (replace with an empty set).",
+)
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def label_assign(
+    entity_uuid: str,
+    entity_type: str,
+    label_refs: tuple[str, ...],
+    clear: bool,
+    json_mode: bool,
+) -> None:
+    """Replace the Labels on one form, check-in, or workflow (web picker parity).
+
+    \b
+    Same as the chip picker in the Dailybot web app: the list you pass becomes
+    the full set. Use --clear to detach every Label. Add or remove on many
+    items at once with `label batch`.
+    """
+    label_uuids: list[str] = _parse_label_uuid_list(label_refs)
+    if clear and label_uuids:
+        raise click.UsageError("Pass either --label or --clear, not both.")
+    if not clear and not label_uuids:
+        raise click.UsageError("Pass at least one --label, or --clear to detach all.")
+
+    client = require_auth()
+    try:
+        with console.status("Updating labels..."):
+            data: dict[str, Any] = client.assign_entity_labels(
+                entity_type,
+                entity_uuid,
+                label_uuids,
+            )
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    attached: list[dict[str, Any]] = data.get("labels") or []
+    print_success(f"Updated labels on {entity_type} {data.get('uuid', entity_uuid)}.")
+    print_label_assignment(str(data.get("uuid", entity_uuid)), attached)
+
+
+@label.command("batch")
+@click.option(
+    "--type",
+    "entity_type",
+    required=True,
+    callback=_parse_label_entity_type,
+    help="Entity type: forms, checkins, or workflows (automations alias).",
+)
+@click.option(
+    "--uuids",
+    required=True,
+    help="Comma-separated form, check-in, or workflow UUIDs.",
+)
+@click.option(
+    "--label",
+    "label_refs",
+    multiple=True,
+    help="Label UUID (repeatable, or comma-separated).",
+)
+@click.option(
+    "--mode",
+    type=click.Choice(_BATCH_MODES, case_sensitive=False),
+    default="add",
+    show_default=True,
+    help="add / remove / replace Labels on every listed entity.",
+)
+@click.option("--json", "json_mode", is_flag=True, help="Emit machine-readable JSON to stdout.")
+def label_batch(
+    entity_type: str,
+    uuids: str,
+    label_refs: tuple[str, ...],
+    mode: str,
+    json_mode: bool,
+) -> None:
+    """Add, remove, or replace Labels on many forms, check-ins, or workflows."""
+    entity_uuids: list[str] = [part.strip() for part in uuids.split(",") if part.strip()]
+    if not entity_uuids:
+        raise click.UsageError("--uuids must contain at least one UUID.")
+    label_uuids: list[str] = _parse_label_uuid_list(label_refs)
+    if not label_uuids:
+        raise click.UsageError("Pass at least one --label.")
+
+    client = require_auth()
+    try:
+        with console.status("Updating labels..."):
+            data: dict[str, Any] = client.batch_entity_labels(
+                entity_type=entity_type,
+                entity_uuids=entity_uuids,
+                label_uuids=label_uuids,
+                mode=mode.lower(),
+            )
+    except APIError as exc:
+        exit_for_api_error(exc, json_mode)
+
+    if json_mode:
+        emit_json(data)
+        return
+
+    updated: int = int(data.get("updated_count") or len(entity_uuids))
+    print_success(f"{mode.lower()} {len(label_uuids)} label(s) on {updated} {entity_type} item(s).")

{dailybot_cli-3.8.0 → dailybot_cli-3.9.0}/dailybot_cli/commands/public_api_helpers.py

@@ -115,6 +115,12 @@ ERROR_CODE_MESSAGES: dict[str, str] = {
         "Your role doesn't allow authoring check-ins. Ask an admin or manager. "
         "The CLI acts within your role and can't elevate."
     ),
+    "paid_plan_required": "Organization Labels require a paid plan with Feature.LABELS enabled.",
+    "feature_not_available": "Organization Labels are not available on this plan.",
+    "guest_not_allowed": "Guests cannot manage organization Labels.",
+    "duplicate_name": "A label with this name already exists.",
+    "archived_label_not_assignable": "This label is archived and cannot be assigned.",
+    "permission_denied": "You don't have permission for this Labels action.",
     "form_edit_forbidden": (
         "You don't have permission to edit this form (you're not the owner or an admin). "
         "The CLI acts within your role and can't elevate."
@@ -514,6 +520,23 @@ def normalize_checkin_list_json(data: dict[str, Any]) -> dict[str, Any]:
     return {"pending_checkins": pending, "count": data.get("count", len(pending))}
 
 
+def normalize_checkin_entity_json(checkin: dict[str, Any]) -> dict[str, Any]:
+    """Ensure authoring check-in payloads expose a stable ``uuid`` field.
+
+    Create/config responses from ``/v1/checkins/`` historically return the
+    follow-up id under ``id`` (not ``uuid``). Forms and Labels use ``uuid``
+    everywhere, so scripting ``checkin create --json`` → ``label assign``
+    was awkward. Copy ``id`` into ``uuid`` when missing; never overwrite an
+    explicit ``uuid``.
+    """
+    enriched: dict[str, Any] = dict(checkin)
+    if not enriched.get("uuid"):
+        legacy_id: Any = enriched.get("id") or enriched.get("followup_uuid")
+        if legacy_id:
+            enriched["uuid"] = str(legacy_id)
+    return enriched
+
+
 def find_pending_checkin(
     pending_checkins: list[dict[str, Any]],
     followup_uuid: str,

{dailybot_cli-3.8.0 → dailybot_cli-3.9.0}/dailybot_cli/commands/user_scoped_actions.py

@@ -16,6 +16,7 @@ from dailybot_cli.commands.public_api_helpers import (
     exit_for_api_error,
     find_pending_checkin,
     get_current_user_uuid,
+    normalize_checkin_entity_json,
     normalize_checkin_list_json,
     parse_answer_flags,
 )
@@ -671,7 +672,7 @@ def execute_checkin_show(
         exit_for_api_error(exc, json_mode)
 
     if json_mode:
-        emit_json(detail)
+        emit_json(normalize_checkin_entity_json(detail))
         return
     print_checkin_detail(detail)
 

{dailybot_cli-3.8.0 → dailybot_cli-3.9.0}/dailybot_cli/display.py

@@ -170,6 +170,49 @@ def print_kudos_wall_of_fame(data: dict[str, Any]) -> None:
     )
 
 
+def print_label_assignment(entity_uuid: str, labels: list[dict[str, Any]]) -> None:
+    """Render the Labels currently attached to one form, check-in, or workflow."""
+    names: list[str] = [str(item.get("name") or item.get("uuid") or "—") for item in labels]
+    attached: str = ", ".join(names) if names else "(none)"
+    console.print(f"[bold]{entity_uuid}[/bold] → {attached}")
+
+
+def print_labels_table(labels: list[dict[str, Any]]) -> None:
+    """Render a compact table of organization Labels."""
+    if not labels:
+        console.print("[dim]No labels found.[/dim]")
+        return
+    table: Table = Table(title="Labels")
+    table.add_column("Name", style="cyan")
+    table.add_column("UUID", style="dim", no_wrap=True)
+    table.add_column("Color")
+    table.add_column("Usage", justify="right")
+    table.add_column("Archived", justify="center")
+    for label in labels:
+        usage: dict[str, Any] = label.get("usage") or {}
+        archived: str = "[green]yes[/green]" if label.get("is_archived") else "[dim]no[/dim]"
+        table.add_row(
+            str(label.get("name", "—")),
+            str(label.get("uuid", "—")),
+            str(label.get("color", "—")),
+            str(usage.get("total", 0)),
+            archived,
+        )
+    console.print(table)
+
+
+def print_featured_summary(data: dict[str, Any]) -> None:
+    """Render Featured UUID list for one entity type."""
+    entity_type: str = str(data.get("entity_type", "—"))
+    uuids: list[str] = [str(value) for value in data.get("entity_uuids", [])]
+    console.print(f"[bold]Featured {entity_type}[/bold] ({len(uuids)})")
+    if not uuids:
+        console.print("[dim]None starred yet.[/dim]")
+        return
+    for uuid in uuids:
+        console.print(f"  • {uuid}")
+
+
 def print_workflows_table(workflows: list[dict[str, Any]]) -> None:
     """Render a compact table of workflows (name, trigger, active, runs)."""
     if not workflows:
@@ -1419,8 +1462,10 @@ def print_form_created(form: dict[str, Any], *, updated: bool = False) -> None:
 def print_checkin_created(checkin: dict[str, Any], *, updated: bool = False) -> None:
     """Display a created (or, with ``updated=True``, edited) check-in + summary."""
     name: str = str(checkin.get("name") or "")
-    checkin_id: str = str(checkin.get("id") or checkin.get("uuid") or "")
-    lines: list[str] = [f"[bold]{name}[/bold]", f"ID: {checkin_id}"]
+    checkin_uuid: str = str(
+        checkin.get("uuid") or checkin.get("id") or checkin.get("followup_uuid") or ""
+    )
+    lines: list[str] = [f"[bold]{name}[/bold]", f"UUID: {checkin_uuid}"]
     schedule: dict[str, Any] = checkin.get("schedule") or {}
     if schedule:
         days: Any = schedule.get("days")

{dailybot_cli-3.8.0 → dailybot_cli-3.9.0}/dailybot_cli/main.py

@@ -14,12 +14,14 @@ from dailybot_cli.commands.checkin import checkin
 from dailybot_cli.commands.config import config
 from dailybot_cli.commands.conversation import conversation
 from dailybot_cli.commands.env import env
+from dailybot_cli.commands.featured import featured
 from dailybot_cli.commands.form import form
 from dailybot_cli.commands.hook import hook
 from dailybot_cli.commands.identity import me, org
 from dailybot_cli.commands.interactive import run_interactive
 from dailybot_cli.commands.interactive_chat import interactive
 from dailybot_cli.commands.kudos import kudos
+from dailybot_cli.commands.label import label
 from dailybot_cli.commands.status import status
 from dailybot_cli.commands.team import team
 from dailybot_cli.commands.uninstall import uninstall
@@ -121,6 +123,8 @@ cli.add_command(user)
 cli.add_command(me)
 cli.add_command(org)
 cli.add_command(workflow)
+cli.add_command(label)
+cli.add_command(featured)
 cli.add_command(agent)
 cli.add_command(chat)
 cli.add_command(conversation)

{dailybot_cli-3.8.0 → dailybot_cli-3.9.0}/dailybot_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dailybot-cli
-Version: 3.8.0
+Version: 3.9.0
 Summary: Dailybot CLI - The command-line bridge between humans and agents. Progress reports, observability, and workflow automation for modern teams across Slack, Google Chat, Discord, MS Teams, and more.
 Author-email: Dailybot <support@dailybot.com>
 License: MIT

{dailybot_cli-3.8.0 → dailybot_cli-3.9.0}/dailybot_cli.egg-info/SOURCES.txt

@@ -25,12 +25,14 @@ dailybot_cli/commands/checkin.py
 dailybot_cli/commands/config.py
 dailybot_cli/commands/conversation.py
 dailybot_cli/commands/env.py
+dailybot_cli/commands/featured.py
 dailybot_cli/commands/form.py
 dailybot_cli/commands/hook.py
 dailybot_cli/commands/identity.py
 dailybot_cli/commands/interactive.py
 dailybot_cli/commands/interactive_chat.py
 dailybot_cli/commands/kudos.py
+dailybot_cli/commands/label.py
 dailybot_cli/commands/public_api_helpers.py
 dailybot_cli/commands/query_options.py
 dailybot_cli/commands/status.py

{dailybot_cli-3.8.0 → dailybot_cli-3.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dailybot-cli"
-version = "3.8.0"
+version = "3.9.0"
 description = "Dailybot CLI - The command-line bridge between humans and agents. Progress reports, observability, and workflow automation for modern teams across Slack, Google Chat, Discord, MS Teams, and more."
 readme = "README.md"
 license = {text = "MIT"}