dailybot-cli 3.27.13__tar.gz → 3.28.0__tar.gz

{dailybot_cli-3.27.13 → dailybot_cli-3.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dailybot-cli
-Version: 3.27.13
+Version: 3.28.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
@@ -799,7 +799,9 @@ dailybot agent register --org-name "My Startup" --agent-name "Claude Code" --ema
 
 This creates an organization, generates an API key, and saves it as a profile automatically. Every registered agent gets a **free Dailybot email address** (e.g. `claude-code@mail.dailybot.co`) so it can send and receive messages worldwide — with humans and other agents alike.
 
-The output includes a **claim URL** — share it with your team admin to connect the org to Slack, Google Chat, Discord, Microsoft Teams, or other platforms. The claim URL expires in 30 days.
+The output includes a **claim URL** and a short "Send this to your human" block — share it with your team admin to connect the org to Slack, Google Chat, Discord, Microsoft Teams, or other platforms. The CLI prints the link's expiry date as the server reports it. Whoever claims it must open the link while signed in to Dailybot on the web, and becomes an admin of the agent's organization. Treat the link like a password.
+
+The registered API key is least-privilege on every plan, and it keeps working after the org is claimed. It can send agent reports and health, read and mark agent messages, and read the account and check-in status. Other commands, including `dailybot agent email send` and `dailybot agent webhook`, are refused with an upgrade hint. Use a key created in Dailybot, or `dailybot login`, for those. On the free plan, reports are capped per day per organization.
 
 ### Agent commands
 

{dailybot_cli-3.27.13 → dailybot_cli-3.28.0}/README.md

@@ -760,7 +760,9 @@ dailybot agent register --org-name "My Startup" --agent-name "Claude Code" --ema
 
 This creates an organization, generates an API key, and saves it as a profile automatically. Every registered agent gets a **free Dailybot email address** (e.g. `claude-code@mail.dailybot.co`) so it can send and receive messages worldwide — with humans and other agents alike.
 
-The output includes a **claim URL** — share it with your team admin to connect the org to Slack, Google Chat, Discord, Microsoft Teams, or other platforms. The claim URL expires in 30 days.
+The output includes a **claim URL** and a short "Send this to your human" block — share it with your team admin to connect the org to Slack, Google Chat, Discord, Microsoft Teams, or other platforms. The CLI prints the link's expiry date as the server reports it. Whoever claims it must open the link while signed in to Dailybot on the web, and becomes an admin of the agent's organization. Treat the link like a password.
+
+The registered API key is least-privilege on every plan, and it keeps working after the org is claimed. It can send agent reports and health, read and mark agent messages, and read the account and check-in status. Other commands, including `dailybot agent email send` and `dailybot agent webhook`, are refused with an upgrade hint. Use a key created in Dailybot, or `dailybot login`, for those. On the free plan, reports are capped per day per organization.
 
 ### Agent commands
 

{dailybot_cli-3.27.13 → dailybot_cli-3.28.0}/dailybot_cli/api_client.py

@@ -1,5 +1,7 @@
 """HTTP client for Dailybot CLI API endpoints."""
 
+import functools
+import platform
 import re
 import time
 import unicodedata
@@ -12,6 +14,7 @@ from urllib.parse import quote, urljoin, urlsplit
 
 import httpx
 
+from dailybot_cli import __version__
 from dailybot_cli.config import (
     API_KEY_SOURCE_ENV_JSON,
     get_agent_name,
@@ -20,6 +23,7 @@ from dailybot_cli.config import (
     get_api_url,
     get_login_token_for,
 )
+from dailybot_cli.install_method import detect_install_method
 
 _MAX_LIST_PAGES: int = 50  # safety cap for paginated list endpoints
 LONG_TIMEOUT_SECS: float = 120.0  # AI-processing endpoints (ask, submit_update)
@@ -33,6 +37,33 @@ ATTACHMENT_TRANSFER_TIMEOUT_SECS: float = LONG_TIMEOUT_SECS
 # never cut off by it. This is the wall-clock ceiling for the whole storage hop.
 ATTACHMENT_DOWNLOAD_DEADLINE_SECS: float = 300.0
 
+# Every request names the CLI build. The backend measures which CLI versions are
+# still in use from this header before it changes anything an old client relies on.
+USER_AGENT_PRODUCT: str = "dailybot-cli"
+USER_AGENT_UNKNOWN: str = "unknown"
+
+
+@functools.lru_cache(maxsize=1)
+def user_agent() -> str:
+    """`dailybot-cli/<ver> (python/<x.y>; <os>; <install_method>)`, computed once."""
+    try:
+        method: str = detect_install_method()
+    except Exception:
+        method = USER_AGENT_UNKNOWN
+    python: str = ".".join(platform.python_version_tuple()[:2])
+    os_name: str = platform.system().lower() or USER_AGENT_UNKNOWN
+    return f"{USER_AGENT_PRODUCT}/{__version__} (python/{python}; {os_name}; {method})"
+
+
+def _base_headers() -> dict[str, str]:
+    """The headers every Dailybot API request carries, before any credential."""
+    return {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "User-Agent": user_agent(),
+    }
+
+
 # HTTP status codes that trigger the alt-credential auth retry. 401 is the
 # standards-compliant "credentials rejected" answer; 403 is what many
 # Django/DRF backends actually send for the same condition (including for
@@ -69,6 +100,9 @@ MAX_PAGE_SIZE: int = 100  # server clamps above this; the client clamps too
 
 MAX_RATE_LIMIT_RETRIES: int = 3  # attempts to retry a generic 429 before raising
 DEFAULT_RETRY_AFTER_SECS: float = 1.0  # backoff floor when a 429 omits Retry-After
+# The registration challenge GET waits out a short 429 on its own; a longer wait is
+# reported to the user instead of leaving the terminal asleep.
+REGISTRATION_MAX_AUTO_WAIT_SECS: float = 10.0
 # A free-plan daily throttle is NOT transient — retrying can never succeed today.
 FREE_PLAN_DAILY_LIMIT_CODE: str = "free_plan_daily_limit_exceeded"
 
@@ -344,6 +378,7 @@ class APIError(Exception):
         code: str | None = None,
         retry_after: float | None = None,
         extra: dict[str, Any] | None = None,
+        credential: str | None = None,
     ) -> None:
         self.status_code: int = status_code
         self.detail: str = detail
@@ -352,6 +387,9 @@ class APIError(Exception):
         # Extra machine-readable context from the error body (e.g. upgrade_url,
         # required_role / current_role). Never a mutable default arg.
         self.extra: dict[str, Any] = extra or {}
+        # Which credential the refused request carried ("api_key" / "bearer"), when
+        # known, so a message about an agent key is never shown to a login session.
+        self.credential: str | None = credential
         super().__init__(f"API error {status_code}: {detail}")
 
 
@@ -476,10 +514,7 @@ class DailyBotClient:
         (``self._prefer_api_key``), the order inverts so the per-repo key
         wins on the first attempt; the 401/403 retry covers the reverse.
         """
-        headers: dict[str, str] = {
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-        }
+        headers: dict[str, str] = _base_headers()
         if authenticated:
             if self.api_key and (self._prefer_api_key or not self.token):
                 headers["X-API-KEY"] = self.api_key
@@ -497,10 +532,7 @@ class DailyBotClient:
         that all endpoints behave consistently. The server accepts both on
         every ``/v1/agent*`` endpoint.
         """
-        headers: dict[str, str] = {
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-        }
+        headers: dict[str, str] = _base_headers()
         if self.api_key and (self._prefer_api_key or not self.token):
             headers["X-API-KEY"] = self.api_key
             self._agent_auth_mode = "api_key"
@@ -517,10 +549,7 @@ class DailyBotClient:
         If the primary was Bearer, tries API key; if the primary was API key,
         tries Bearer. Returns ``None`` when no alternative is available.
         """
-        headers: dict[str, str] = {
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-        }
+        headers: dict[str, str] = _base_headers()
         if self._agent_auth_mode == "bearer" and self.api_key:
             headers["X-API-KEY"] = self.api_key
             self._agent_auth_mode = "api_key"
@@ -810,6 +839,7 @@ class DailyBotClient:
                 code=code,
                 retry_after=retry_after,
                 extra=extra,
+                credential=self._agent_auth_mode,
             )
         if response.status_code == 204:
             return {}
@@ -823,14 +853,20 @@ class DailyBotClient:
                 f"The server returned an unreadable response: {_fallback_detail(response)}"
             ) from exc
 
-    def _send_with_retry(self, send: Callable[[], httpx.Response]) -> httpx.Response:
+    def _send_with_retry(
+        self,
+        send: Callable[[], httpx.Response],
+        *,
+        max_wait_secs: float | None = None,
+    ) -> httpx.Response:
         """Issue a request via ``send`` with bounded retry on a transient 429.
 
         Honors the ``Retry-After`` header and backs off exponentially from it, up
         to ``MAX_RATE_LIMIT_RETRIES`` retries. A ``free_plan_daily_limit_exceeded``
         429 is NOT transient — it is returned immediately (no retry) so the caller
         raises a clear error. Any non-429 response is returned as-is. ``time.sleep``
-        is referenced through the module so tests can patch it.
+        is referenced through the module so tests can patch it. With ``max_wait_secs``,
+        a wait longer than that is not slept: the 429 is returned for the caller to report.
         """
         attempt: int = 0
         while True:
@@ -854,7 +890,10 @@ class DailyBotClient:
                     retry_after = float(raw_retry)
                 except ValueError:
                     retry_after = DEFAULT_RETRY_AFTER_SECS
-            time.sleep(retry_after * (2**attempt))
+            wait: float = retry_after * (2**attempt)
+            if max_wait_secs is not None and wait > max_wait_secs:
+                return response
+            time.sleep(wait)
             attempt += 1
 
     def _paginated_get(
@@ -3624,7 +3663,9 @@ class DailyBotClient:
                 method,
                 url,
                 content=data,
-                headers=headers,
+                # Only the presign's own headers (they win: a signed upload may pin
+                # them) plus the User-Agent. Never a Dailybot credential.
+                headers={"User-Agent": user_agent(), **headers},
                 timeout=ATTACHMENT_TRANSFER_TIMEOUT_SECS,
                 follow_redirects=False,
             )
@@ -4145,7 +4186,7 @@ class DailyBotClient:
             with httpx.stream(
                 "GET",
                 location,
-                headers={"Accept-Encoding": "identity"},
+                headers={"Accept-Encoding": "identity", "User-Agent": user_agent()},
                 timeout=ATTACHMENT_TRANSFER_TIMEOUT_SECS,
                 follow_redirects=False,
             ) as response:
@@ -4839,14 +4880,21 @@ class DailyBotClient:
     # --- Agent registration endpoints ---
 
     def get_registration_challenge(self) -> dict[str, Any]:
-        """GET /v1/agent/register/challenge/ — no auth required."""
-        response: httpx.Response = self._guard_transport(
-            lambda: httpx.get(
-                f"{self.api_url}/v1/agent/register/challenge/",
-                headers=self._headers(authenticated=False),
-                timeout=self.timeout,
+        """GET /v1/agent/register/challenge/ — no auth required.
+
+        A read, so a short 429 is waited out (``Retry-After``). The POST that follows
+        is never retried this way: every attempt consumes its challenge.
+        """
+        response: httpx.Response = self._send_with_retry(
+            lambda: self._guard_transport(
+                lambda: httpx.get(
+                    f"{self.api_url}/v1/agent/register/challenge/",
+                    headers=self._headers(authenticated=False),
+                    timeout=self.timeout,
+                ),
+                method="GET",
             ),
-            method="GET",
+            max_wait_secs=REGISTRATION_MAX_AUTO_WAIT_SECS,
         )
         return self._handle_response(response)
 

{dailybot_cli-3.27.13 → dailybot_cli-3.28.0}/dailybot_cli/commands/agent.py

@@ -9,6 +9,7 @@ import click
 
 from dailybot_cli import ledger
 from dailybot_cli.api_client import APIError, DailyBotClient
+from dailybot_cli.commands.public_api_helpers import agent_error_message
 from dailybot_cli.config import (
     RepoEnvError,
     RepoProfileError,
@@ -80,9 +81,30 @@ def _reset_init_nudge() -> None:
     _NUDGE_SHOWN = False
 
 
-# Challenge constants (from backend registration_challenge_service.py)
-_CHALLENGE_WORD_COUNT: int = 52
+# Registration challenge (API contract rev 1). It is a compatibility speed bump, not a
+# security control: the answer is the session code times the number of words in the
+# instruction. The CLI counts the words so the server can change the wording; 52 is
+# today's count, kept only as the fallback for an instruction too short to be real.
+_CHALLENGE_LEGACY_WORD_COUNT: int = 52
+_CHALLENGE_MIN_WORDS: int = 5
 _CHALLENGE_NUMBER_RE: re.Pattern[str] = re.compile(r"session is (\d+)\.")
+_CHALLENGE_UNREADABLE_MESSAGE: str = (
+    "Could not read the registration challenge from the server. This CLI may be too old "
+    "for it: run `dailybot upgrade`, then try again."
+)
+_CHALLENGE_EXPIRED_CODE: str = "challenge_expired"
+_SCOPE_REFUSAL_CODE: str = "plan_upgrade_required"
+_RATE_LIMITED_MESSAGE: str = "Rate limited."
+_RATE_LIMITED_DEFAULT_HINT: str = "Try again in a few minutes."
+
+
+def _key_is_refused(exc: APIError) -> bool:
+    """True when validating a key proves it is unusable.
+
+    A 403 ``plan_upgrade_required`` means the key authenticated but the call is out of
+    its scope (a self-registered key is least-privilege), so the key itself is valid.
+    """
+    return exc.status_code in (401, 403) and exc.code != _SCOPE_REFUSAL_CODE
 
 
 def _resolve_agent_context(
@@ -301,7 +323,7 @@ def agent_configure(
             with console.status("Validating API key..."):
                 client.get_agent_health(agent_name=name)
         except APIError as e:
-            if e.status_code in (401, 403):
+            if _key_is_refused(e):
                 print_error("API key is invalid or unauthorized.")
                 raise SystemExit(1)
             # Non-auth error means the key itself is valid
@@ -464,7 +486,7 @@ def _init_personal(questionary: Any) -> None:
             with console.status("Validating API key..."):
                 client.get_agent_health(agent_name=name)
         except APIError as exc:
-            if exc.status_code in (401, 403):
+            if _key_is_refused(exc):
                 print_error("API key is invalid or unauthorized. Nothing was saved.")
                 raise SystemExit(1)
             # Non-auth error → key is valid; the failure is unrelated.
@@ -660,7 +682,7 @@ def agent_update(
             print_pending_agent_messages(pending)
         _maybe_show_init_nudge(agent_name)
     except APIError as e:
-        print_error(e.detail)
+        print_error(agent_error_message(e))
         raise SystemExit(1)
 
 
@@ -715,7 +737,7 @@ def agent_health(
                 )
             print_agent_health(result)
     except APIError as e:
-        print_error(e.detail)
+        print_error(agent_error_message(e))
         raise SystemExit(1)
 
 
@@ -755,7 +777,7 @@ def webhook_register(
             )
         print_webhook_result(result)
     except APIError as e:
-        print_error(e.detail)
+        print_error(agent_error_message(e))
         raise SystemExit(1)
 
 
@@ -778,7 +800,7 @@ def webhook_unregister(ctx: click.Context, name: str | None, profile: str | None
             result: dict[str, Any] = client.unregister_agent_webhook(agent_name=agent_name)
         print_success(result.get("detail", "Webhook unregistered."))
     except APIError as e:
-        print_error(e.detail)
+        print_error(agent_error_message(e))
         raise SystemExit(1)
 
 
@@ -844,7 +866,7 @@ def message_send(
             )
         print_agent_message_sent(result)
     except APIError as e:
-        print_error(e.detail)
+        print_error(agent_error_message(e))
         raise SystemExit(1)
 
 
@@ -872,7 +894,7 @@ def message_list(ctx: click.Context, name: str | None, profile: str | None, pend
             )
         print_agent_messages(messages)
     except APIError as e:
-        print_error(e.detail)
+        print_error(agent_error_message(e))
         raise SystemExit(1)
 
 
@@ -898,7 +920,7 @@ def message_claim(ctx: click.Context, message_ids: tuple[str, ...], profile: str
         count: int = result.get("updated", 0)
         print_success(f"Marked {count} message(s) as read.")
     except APIError as e:
-        print_error(e.detail)
+        print_error(agent_error_message(e))
         raise SystemExit(1)
 
 
@@ -925,7 +947,7 @@ def message_claim_all(ctx: click.Context, name: str | None, profile: str | None)
             )
         print_success("All pending messages marked as delivered.")
     except APIError as e:
-        print_error(e.detail)
+        print_error(agent_error_message(e))
         raise SystemExit(1)
 
 
@@ -993,11 +1015,11 @@ def email_send(
             )
         print_agent_email_sent(result)
     except APIError as e:
-        if e.status_code == 429:
+        if e.status_code == 429 and not e.code:
             print_error("Hourly email limit exceeded. Try again later.")
             print_info(e.detail)
         else:
-            print_error(e.detail)
+            print_error(agent_error_message(e))
         raise SystemExit(1)
 
 
@@ -1005,13 +1027,38 @@ def email_send(
 
 
 def _solve_challenge(instruction: str) -> int:
-    """Extract random_number from challenge instruction and compute the answer."""
+    """Answer the challenge: the session code times the instruction's word count."""
     match: re.Match[str] | None = _CHALLENGE_NUMBER_RE.search(instruction)
     if not match:
-        print_error("Could not parse challenge. Please report this issue.")
+        print_error(_CHALLENGE_UNREADABLE_MESSAGE)
         raise SystemExit(1)
     random_number: int = int(match.group(1))
-    return random_number * _CHALLENGE_WORD_COUNT
+    word_count: int = len(instruction.split())
+    if word_count < _CHALLENGE_MIN_WORDS:
+        word_count = _CHALLENGE_LEGACY_WORD_COUNT
+    return random_number * word_count
+
+
+def _is_challenge_expired(exc: APIError) -> bool:
+    """True for an expired challenge. A server older than contract rev 1 sends no code."""
+    if exc.code:
+        return exc.code == _CHALLENGE_EXPIRED_CODE
+    detail: str = exc.detail.lower()
+    return "challenge" in detail and "expired" in detail
+
+
+def _registration_error_message(exc: APIError) -> str:
+    """What a failed registration tells the user: the code's message, else the detail."""
+    if exc.code:
+        return agent_error_message(exc)
+    if exc.status_code == 429:
+        hint: str = (
+            f"Try again in {int(exc.retry_after)}s."
+            if exc.retry_after
+            else _RATE_LIMITED_DEFAULT_HINT
+        )
+        return f"{_RATE_LIMITED_MESSAGE} {hint}"
+    return exc.detail
 
 
 @agent.command(name="register")
@@ -1058,21 +1105,16 @@ def agent_register(
             )
 
     try:
-        result: dict[str, Any] = _attempt_register()
+        try:
+            result: dict[str, Any] = _attempt_register()
+        except APIError as e:
+            if not _is_challenge_expired(e):
+                raise
+            # Every attempt consumes its challenge: retry once with a fresh one.
+            result = _attempt_register()
     except APIError as e:
-        if "expired" in e.detail.lower():
-            # Auto-retry once with a fresh challenge
-            try:
-                result = _attempt_register()
-            except APIError as retry_e:
-                print_error(retry_e.detail)
-                raise SystemExit(1)
-        elif e.status_code == 429:
-            print_error("Rate limited. Try again in a few minutes.")
-            raise SystemExit(1)
-        else:
-            print_error(e.detail)
-            raise SystemExit(1)
+        print_error(_registration_error_message(e))
+        raise SystemExit(1)
 
     # Save profile
     api_key: str | None = result.get("api_key")
@@ -1082,8 +1124,3 @@ def agent_register(
     # Display result
     result["profile"] = slug
     print_registration_result(result)
-    claim_url: str = result.get("claim_url", "")
-    if claim_url:
-        print_info(
-            "Share the claim URL with your team admin to connect this org to Slack or Google Chat. The URL expires in 30 days."
-        )

{dailybot_cli-3.27.13 → dailybot_cli-3.28.0}/dailybot_cli/commands/public_api_helpers.py

@@ -961,6 +961,78 @@ def exit_for_tasks_error(
     raise SystemExit(code)
 
 
+# Agent self-registration and claim (API contract rev 1). Scoped to agent commands
+# (looked up only by `agent_error_message`), because generic names such as
+# `missing_fields` or `invalid_answer` could mean something else on another surface.
+# `challenge_expired` is retried once by `agent register` before it reaches the user.
+REGISTRATION_CODE_MESSAGES: dict[str, str] = {
+    "missing_fields": "The registration request was missing required fields. Run `dailybot upgrade`, then try again.",
+    "invalid_answer": (
+        "The registration challenge answer was not a number. This CLI may be too old for "
+        "the server: run `dailybot upgrade`, then try again."
+    ),
+    "challenge_invalid": "The registration challenge was not recognized. Run the command again to get a new one.",
+    "challenge_used": (
+        "That registration challenge was already used (every attempt consumes it). Run the "
+        "command again to get a new one."
+    ),
+    "challenge_expired": "The registration challenge expired. Run the command again to get a new one.",
+    "answer_incorrect": (
+        "The registration challenge answer was rejected. This CLI may be too old for the "
+        "server: run `dailybot upgrade`, then try again."
+    ),
+    "reason_too_short": "The registration reason is too short (at least 20 characters).",
+    "reason_echoes_instruction": (
+        "The registration reason repeats the challenge instruction. Describe why the agent is registering."
+    ),
+    "registration_rate_limited": "Rate limited: too many registration attempts.",
+    "claim_token_unavailable": (
+        "No claim link is available: the organization was already claimed or the link "
+        "expired. A new link cannot be issued yet."
+    ),
+}
+
+
+# Agent commands run on agent keys, where these two codes mean something narrower than
+# on a person's session (API contract rev 1: a self-registered key is least-privilege
+# on every plan, and an org admin can delete the agent behind it).
+_INVALID_CREDENTIALS_CODE: str = "invalid_credentials"
+_API_KEY_CREDENTIAL: str = "api_key"
+AGENT_CODE_MESSAGES: dict[str, str] = {
+    "plan_upgrade_required": (
+        "This credential is not allowed to do that. On the free plan, and with a "
+        "self-registered agent key on any plan, agent commands are limited to agent "
+        "reports, health and messages; `agent email` and `agent webhook` are not included."
+    ),
+    "invalid_credentials": (
+        "This agent key was rejected. An org admin may have deleted the agent, or the "
+        "key belongs to another server (`dailybot env show`). Rotate the key or run "
+        "`dailybot login`."
+    ),
+}
+
+
+def agent_error_message(exc: APIError) -> str:
+    """The user-facing message for an agent command's ``APIError``.
+
+    Dispatches on ``code`` (agent-specific copy first, then registration, then the
+    shared map); an unknown or absent code falls back to the server's ``detail``. The
+    agent-key copy for ``invalid_credentials`` is used only when the refused request
+    carried an API key, never for a login session. A 429 gets the wait hint.
+    """
+    code: str | None = exc.code
+    base: str | None = None
+    if code:
+        agent_copy: str | None = AGENT_CODE_MESSAGES.get(code)
+        if code == _INVALID_CREDENTIALS_CODE and exc.credential != _API_KEY_CREDENTIAL:
+            agent_copy = None
+        base = agent_copy or REGISTRATION_CODE_MESSAGES.get(code) or ERROR_CODE_MESSAGES.get(code)
+    message: str = (
+        _augment_code_message(base, code, exc.extra or {}) if base and code else exc.detail
+    )
+    return f"{message}{_throttle_hint(exc, _retry_after_seconds(exc))}"
+
+
 def exit_for_api_error(
     exc: APIError,
     json_mode: bool,

{dailybot_cli-3.27.13 → dailybot_cli-3.28.0}/dailybot_cli/config.py

@@ -48,6 +48,8 @@ CREDENTIALS_FILE: Path = CONFIG_DIR / "credentials.json"
 CONFIG_FILE: Path = CONFIG_DIR / "config.json"
 ORG_CACHE_FILE: Path = CONFIG_DIR / "org_cache.json"
 AGENTS_FILE: Path = CONFIG_DIR / "agents.json"
+SECRET_FILE_MODE: int = 0o600
+CONFIG_DIR_MODE: int = 0o700
 
 
 def get_config_dir() -> Path:
@@ -58,10 +60,37 @@ def get_config_dir() -> Path:
     """
     env_override: str | None = os.environ.get("DAILYBOT_CONFIG_DIR")
     path: Path = Path(env_override) if env_override else CONFIG_DIR
-    path.mkdir(parents=True, exist_ok=True)
+    # The mode applies only when the directory is created: an existing one is never
+    # loosened (or tightened behind the user's back).
+    path.mkdir(mode=CONFIG_DIR_MODE, parents=True, exist_ok=True)
     return path
 
 
+def _tighten_before_write(fd: int) -> None:
+    """Set 0o600 on an open descriptor before any secret byte is written.
+
+    ``os.fchmod`` is POSIX-only (Windows gains it in Python 3.13); there the caller
+    falls back to ``os.chmod`` after the write, where POSIX modes are advisory anyway.
+    """
+    if hasattr(os, "fchmod"):
+        os.fchmod(fd, SECRET_FILE_MODE)
+
+
+def _write_secret_file(path: Path, text: str) -> None:
+    """Write a secret store with mode 0o600 from the first byte.
+
+    A write-then-chmod leaves a umask-permission window while the file already holds
+    a token or key. A pre-existing file keeps its old mode through os.open, so the
+    descriptor is tightened before the first byte is written.
+    """
+    fd: int = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, SECRET_FILE_MODE)
+    _tighten_before_write(fd)
+    with os.fdopen(fd, "w") as handle:
+        handle.write(text)
+    if not hasattr(os, "fchmod"):
+        os.chmod(path, SECRET_FILE_MODE)
+
+
 def _credentials_path() -> Path:
     return get_config_dir() / "credentials.json"
 
@@ -100,7 +129,8 @@ def save_credentials(
     """Save credentials to disk."""
     creds_path: Path = _credentials_path()
     get_config_dir()
-    creds_path.write_text(
+    _write_secret_file(
+        creds_path,
         json.dumps(
             {
                 "token": token,
@@ -110,10 +140,8 @@ def save_credentials(
                 "api_url": api_url,
             },
             indent=2,
-        )
+        ),
     )
-    # Restrict file permissions (owner read/write only)
-    os.chmod(creds_path, 0o600)
 
 
 def clear_credentials() -> None:
@@ -255,8 +283,7 @@ def save_config(data: dict[str, Any]) -> None:
             existing[key] = value
     get_config_dir()
     config_path: Path = _config_path()
-    config_path.write_text(json.dumps(existing, indent=2))
-    os.chmod(config_path, 0o600)
+    _write_secret_file(config_path, json.dumps(existing, indent=2))
 
 
 def get_api_key() -> str | None:
@@ -325,7 +352,7 @@ def save_org_cache(email: str, organizations: list[dict[str, Any]]) -> None:
     """Cache the org list from request_code for UUID resolution in step 2."""
     get_config_dir()
     data: dict[str, Any] = {"email": email, "organizations": organizations}
-    _org_cache_path().write_text(json.dumps(data))
+    _write_secret_file(_org_cache_path(), json.dumps(data))
 
 
 def load_org_cache(email: str) -> list[dict[str, Any]] | None:
@@ -375,8 +402,7 @@ def save_org_plan(organization_uuid: str, plan: str | None) -> None:
         data.pop(organization_uuid, None)
     else:
         data[organization_uuid] = plan
-    cache_path.write_text(json.dumps(data, indent=2))
-    os.chmod(cache_path, 0o600)
+    _write_secret_file(cache_path, json.dumps(data, indent=2))
 
 
 def get_org_plan(organization_uuid: str | None) -> str | None:
@@ -440,8 +466,7 @@ def _save_agents(data: dict[str, Any]) -> None:
     """Write agents.json with restricted permissions."""
     get_config_dir()
     agents_path: Path = _agents_path()
-    agents_path.write_text(json.dumps(data, indent=2))
-    os.chmod(agents_path, 0o600)
+    _write_secret_file(agents_path, json.dumps(data, indent=2))
 
 
 def save_agent_profile(
@@ -1178,11 +1203,14 @@ def save_repo_env(payload: dict[str, Any], *, cwd: Path | None = None) -> Path:
     serialized: str = json.dumps(_normalize_env_payload(payload), indent=2) + "\n"
     # Create with 0o600 from the very first byte — a plain write-then-chmod
     # leaves a umask-permission window while the file already holds API keys.
-    fd: int = os.open(env_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    # A pre-existing file keeps its old mode through os.open — tighten the descriptor
+    # before writing.
+    fd: int = os.open(env_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, SECRET_FILE_MODE)
+    _tighten_before_write(fd)
     with os.fdopen(fd, "w") as handle:
         handle.write(serialized)
-    # A pre-existing file keeps its old mode through os.open — tighten it.
-    os.chmod(env_path, 0o600)
+    if not hasattr(os, "fchmod"):
+        os.chmod(env_path, SECRET_FILE_MODE)
     return env_path
 
 

{dailybot_cli-3.27.13 → dailybot_cli-3.28.0}/dailybot_cli/display.py

@@ -6,6 +6,7 @@ tag, so every such message is escaped before interpolation.
 """
 
 import unicodedata
+from datetime import datetime, timezone
 from typing import Any
 
 import click
@@ -766,24 +767,64 @@ def print_env_profiles_table(
     console.print(table)
 
 
+CLAIM_EXPIRY_FALLBACK: str = "See the claim page for when it expires."
+
+
+def format_claim_expiry(value: Any) -> str:
+    """`claim_expires_at` (ISO 8601 UTC) as `YYYY-MM-DD HH:MM UTC`; odd values as sent."""
+    if not isinstance(value, str) or not value.strip():
+        return ""
+    try:
+        parsed: datetime = datetime.fromisoformat(value.strip().replace("Z", "+00:00"))
+    except ValueError:
+        return value.strip()
+    # The contract sends UTC; a value without an offset is read as UTC, not local time.
+    parsed = (
+        parsed.replace(tzinfo=timezone.utc)
+        if parsed.tzinfo is None
+        else parsed.astimezone(timezone.utc)
+    )
+    return parsed.strftime("%Y-%m-%d %H:%M UTC")
+
+
 def print_registration_result(data: dict[str, Any]) -> None:
-    """Display agent registration result."""
+    """Display an agent registration: the panel, then what to send the human owner.
+
+    The API key is saved to the profile by the caller and never shown here.
+    """
     table: Table = Table(show_header=False, box=None, padding=(0, 2))
     table.add_column(style="bold")
     table.add_column(no_wrap=True, overflow="fold")
-    table.add_row("Agent", data.get("agent_name", ""))
-    agent_email: str = data.get("agent_email", "")
+    table.add_row("Agent", escape(str(data.get("agent_name", ""))))
+    agent_email: str = str(data.get("agent_email") or "")
     if agent_email:
-        table.add_row("Email", f"[bold]{agent_email}[/bold]")
-    table.add_row("Org", data.get("org_name", ""))
+        table.add_row("Email", f"[bold]{escape(agent_email)}[/bold]")
+    table.add_row("Org", escape(str(data.get("org_name", ""))))
     if data.get("profile"):
-        table.add_row("Profile", data["profile"])
-    claim_url: str = data.get("claim_url", "")
+        table.add_row("Profile", escape(str(data["profile"])))
+    claim_url: str = str(data.get("claim_url") or "")
+    expiry: str = format_claim_expiry(data.get("claim_expires_at"))
     if claim_url:
-        table.add_row("Claim URL", f"[bold cyan]{claim_url}[/bold cyan]")
+        table.add_row("Claim URL", f"[bold cyan]{escape(claim_url)}[/bold cyan]")
+        if expiry:
+            table.add_row("Claim expires", escape(expiry))
     console.print(Panel(table, title="[bold]Agent Registered[/bold]", border_style="green"))
-    if claim_url:
-        console.print(f"\nClaim URL: {claim_url}")
+    if not claim_url:
+        return
+    expires_line: str = f"The link expires on {expiry}." if expiry else CLAIM_EXPIRY_FALLBACK
+    console.print(
+        "\n[bold]Send this to your human[/bold] (the person who will own this organization):\n"
+    )
+    console.print(f"Claim URL: [bold cyan]{escape(claim_url)}[/bold cyan]")
+    console.print(
+        "Open it while signed in to Dailybot on the web to become an admin of this "
+        "organization, then connect it to Slack, Microsoft Teams, Discord or Google Chat. "
+        f"{escape(expires_line)}"
+    )
+    console.print(
+        "[dim]Treat the link like a password: anyone who opens it signed in can claim "
+        "the organization.[/dim]"
+    )
 
 
 def print_update_result(data: dict[str, Any]) -> None:

{dailybot_cli-3.27.13 → dailybot_cli-3.28.0}/dailybot_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dailybot-cli
-Version: 3.27.13
+Version: 3.28.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
@@ -799,7 +799,9 @@ dailybot agent register --org-name "My Startup" --agent-name "Claude Code" --ema
 
 This creates an organization, generates an API key, and saves it as a profile automatically. Every registered agent gets a **free Dailybot email address** (e.g. `claude-code@mail.dailybot.co`) so it can send and receive messages worldwide — with humans and other agents alike.
 
-The output includes a **claim URL** — share it with your team admin to connect the org to Slack, Google Chat, Discord, Microsoft Teams, or other platforms. The claim URL expires in 30 days.
+The output includes a **claim URL** and a short "Send this to your human" block — share it with your team admin to connect the org to Slack, Google Chat, Discord, Microsoft Teams, or other platforms. The CLI prints the link's expiry date as the server reports it. Whoever claims it must open the link while signed in to Dailybot on the web, and becomes an admin of the agent's organization. Treat the link like a password.
+
+The registered API key is least-privilege on every plan, and it keeps working after the org is claimed. It can send agent reports and health, read and mark agent messages, and read the account and check-in status. Other commands, including `dailybot agent email send` and `dailybot agent webhook`, are refused with an upgrade hint. Use a key created in Dailybot, or `dailybot login`, for those. On the free plan, reports are capped per day per organization.
 
 ### Agent commands
 

{dailybot_cli-3.27.13 → dailybot_cli-3.28.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dailybot-cli"
-version = "3.27.13"
+version = "3.28.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"}