recala-cli 0.6.0__py3-none-any.whl

recala_cli/config.py

@@ -0,0 +1,176 @@
+"""Where the CLI keeps its settings and credentials, and the order it reads them in.
+
+Files in one directory (RECALA_CONFIG_DIR, else $XDG_CONFIG_HOME/recala,
+else ~/.config/recala), all written 0600:
+
+* ``config.json``: the API URL, the web URL and the active organization. Not secret.
+* ``credentials.json``: the stored session or key, never printed.
+* ``grants.json``: the person's [a]ll answer for the current sign-in (see ``confirm``).
+* ``onboarding.json``: which onboarding steps this machine finished, per organization.
+
+Precedence, most specific first: a flag, then an environment variable, then the
+file. Agents and CI set RECALA_API_KEY and RECALA_ORG and never touch the files.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import time
+from pathlib import Path
+from typing import Any
+from uuid import UUID
+
+from recala_cli.errors import CliError, ExitCode
+
+DEFAULT_API_URL = "https://recala-production.up.railway.app"
+DEFAULT_WEB_URL = "https://recala.co"
+_CONFIG = "config.json"
+_CREDENTIALS = "credentials.json"
+_GRANTS = "grants.json"
+_ONBOARDING = "onboarding.json"
+_SLUGS = "org-slugs.json"
+_SLUG_TTL_SECONDS = 24 * 60 * 60
+
+
+def config_dir() -> Path:
+    explicit = os.environ.get("RECALA_CONFIG_DIR")
+    if explicit:
+        return Path(explicit)
+    base = os.environ.get("XDG_CONFIG_HOME") or str(Path.home() / ".config")
+    return Path(base) / "recala"
+
+
+def api_url(flag: str | None = None) -> str:
+    return (flag or os.environ.get("RECALA_API_URL") or _read(_CONFIG).get("api_url") or DEFAULT_API_URL).rstrip("/")
+
+
+def web_url() -> str:
+    """Where the person's browser goes (sign-in, Search Console, checkout): RECALA_WEB_URL, else what login learned."""
+    return (os.environ.get("RECALA_WEB_URL") or _read(_CONFIG).get("web_url") or DEFAULT_WEB_URL).rstrip("/")
+
+
+def set_web_url(url: str) -> None:
+    settings = _read(_CONFIG)
+    settings["web_url"] = url.rstrip("/")
+    _write(_CONFIG, settings)
+
+
+def active_org(flag: str | None = None) -> str | None:
+    selector = flag if flag is not None else os.environ.get("RECALA_ORG")
+    if selector is not None:
+        if not selector.strip():
+            raise CliError(ExitCode.USAGE, "invalid_org", "--org needs a company name, slug or id.")
+        return selector
+    return _read(_CONFIG).get("org_id")
+
+
+def saved_active_org() -> str | None:
+    """The company saved by `recala company use`, ignoring --org and RECALA_ORG."""
+    return _read(_CONFIG).get("org_id")
+
+
+def set_active_org(org_id: str) -> None:
+    settings = _read(_CONFIG)
+    settings["org_id"] = org_id
+    _write(_CONFIG, settings)
+
+
+def is_org_id(value: str) -> bool:
+    try:
+        UUID(value)
+    except ValueError:
+        return False
+    return True
+
+
+def environment_token() -> str | None:
+    return os.environ.get("RECALA_API_KEY") or os.environ.get("RECALA_TOKEN")
+
+
+def load_credentials() -> dict[str, Any]:
+    return _read(_CREDENTIALS)
+
+
+def save_credentials(credentials: dict[str, Any]) -> None:
+    _write(_CREDENTIALS, credentials)
+
+
+def forget_credentials() -> None:
+    (config_dir() / _CREDENTIALS).unlink(missing_ok=True)
+    forget_grant()
+
+
+def load_grant() -> dict[str, Any]:
+    return _read(_GRANTS)
+
+
+def save_grant(grant: dict[str, Any]) -> None:
+    _write(_GRANTS, grant)
+
+
+def forget_grant() -> None:
+    (config_dir() / _GRANTS).unlink(missing_ok=True)
+
+
+def onboarding_progress(org_id: str) -> dict[str, Any]:
+    entry = _read(_ONBOARDING).get(org_id)
+    return entry if isinstance(entry, dict) else {}
+
+
+def save_onboarding_progress(org_id: str, progress: dict[str, Any]) -> None:
+    everything = _read(_ONBOARDING)
+    everything[org_id] = progress
+    _write(_ONBOARDING, everything)
+
+
+def cached_org_slug(org_id: str) -> str | None:
+    """A company's slug read in the last day: /me omits slugs, and reading each company costs a round trip."""
+    entry = _read_quietly(_SLUGS).get(org_id)
+    fresh = isinstance(entry, dict) and time.time() - float(entry.get("at") or 0) < _SLUG_TTL_SECONDS
+    return entry.get("slug") if fresh and isinstance(entry.get("slug"), str) else None
+
+
+def remember_org_slugs(identities: dict[str, dict[str, Any]]) -> None:
+    learned = {org_id: {"slug": found["slug"], "at": time.time()}
+               for org_id, found in identities.items() if isinstance(found.get("slug"), str)}
+    if not learned:
+        return
+    try:
+        _write(_SLUGS, {**_read_quietly(_SLUGS), **learned})
+    except OSError:
+        pass  # a cache that cannot be written only costs the next command a read
+
+
+def _read_quietly(name: str) -> dict[str, Any]:
+    try:
+        return _read(name)
+    except (OSError, ValueError):
+        return {}
+
+
+def _read(name: str) -> dict[str, Any]:
+    path = config_dir() / name
+    if not path.exists():
+        return {}
+    data = json.loads(path.read_text())
+    return data if isinstance(data, dict) else {}
+
+
+def _write(name: str, data: dict[str, Any]) -> None:
+    """Atomic and owner-only: a crash never leaves half a file, and no other user can read it.
+
+    ``mkstemp`` creates the file 0600 (a umask can only narrow that), and ``os.replace``
+    swaps it in whole, so even a credentials file some other tool left 0644 comes back 0600.
+    """
+    directory = config_dir()
+    directory.mkdir(parents=True, exist_ok=True, mode=0o700)
+    handle, temporary = tempfile.mkstemp(dir=directory, prefix=f".{name}.")
+    try:
+        with os.fdopen(handle, "w") as stream:
+            json.dump(data, stream)
+        os.replace(temporary, directory / name)
+    except BaseException:
+        Path(temporary).unlink(missing_ok=True)
+        raise

recala_cli/confirm.py

@@ -0,0 +1,137 @@
+"""Every write asks the person first: [y]es / [n]o / [a]ll (founder decision, 5 Oct 2026).
+
+In a terminal the CLI asks before each write. ``a`` confirms the rest of this
+command and records a grant for this sign-in (``grants.json``, bound to the
+session's local id, 12 hours at most, gone at logout or the next login).
+
+Without a terminal (an agent, a pipe, --json) nothing ever prompts. A write then
+goes ahead only with:
+
+* a prior [a]ll grant for this sign-in (``recala grant``, or an ``a`` answered
+  earlier), or
+* an API key: its scopes are its authorization, checked by the server (spending
+  also needs the cost preview the server demands). An action that publishes
+  (approve, schedule, unschedule, unpublish, or a key that may do those) also
+  needs --yes, and --yes is accepted only from a key that holds ``publish``.
+
+Otherwise nothing is sent and the command exits 10. This module only decides
+whether to send; every request still meets the server's own gates.
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from datetime import datetime
+from typing import Any
+
+import click
+
+from recala_cli import auth, config
+from recala_cli.client import RecalaClient
+from recala_cli.endpoints import ME
+from recala_cli.errors import CliError, ExitCode
+from recala_cli.output import notify
+
+GRANT_HOURS = 12
+PUBLISH_SCOPE = "publish"
+_ANSWERS = {"y": "yes", "yes": "yes", "n": "no", "no": "no", "": "no", "a": "all", "all": "all"}
+_ATTEMPTS = 3
+
+
+def is_interactive(ctx: click.Context) -> bool:
+    """A person at a terminal: never under --json, and only when both stdin and stderr are a TTY."""
+    seams = ctx.find_root().obj or {}
+    if seams.get("as_json"):
+        return False
+    forced = seams.get("interactive")
+    if forced is not None:
+        return bool(forced)
+    return sys.stdin.isatty() and sys.stderr.isatty()
+
+
+def grant_status() -> dict[str, Any]:
+    grant, session = config.load_grant(), auth.session_id()
+    active = bool(session) and grant.get("session_id") == session and time.time() < float(grant.get("expires_at") or 0)
+    return {"active": active, "expires_at": grant.get("expires_at") if active else None}
+
+
+def require_current_signin() -> None:
+    if (not config.environment_token() and auth.credential_kind() in {"session", "access_token"}
+            and not auth.session_id()):
+        raise CliError(ExitCode.NOT_AUTHENTICATED, "legacy_signin",
+                       "This sign-in predates saved confirmations. Run `recala login` again, then `recala grant`.")
+
+
+def record_grant() -> dict[str, Any]:
+    require_current_signin()
+    session = auth.session_id()
+    if not session:
+        raise CliError(ExitCode.CONFLICT, "no_session",
+                       "Only a person's sign-in (`recala login`) can hold an [a]ll grant; an API key uses its scopes.")
+    now = time.time()
+    config.save_grant({"session_id": session, "granted_at": now, "expires_at": now + GRANT_HOURS * 3600})
+    return grant_status()
+
+
+def confirm_write(ctx: click.Context, client: RecalaClient | None, summary: str, *, publishes: bool = False,
+                  yes: bool = False) -> None:
+    """Return when the person (or the key) confirmed this write; raise exit 10 when nothing may be sent."""
+    require_current_signin()
+    seams = ctx.find_root().obj
+    if seams.get("all_confirmed"):
+        return
+    with_key = auth.credential_kind() == "api_key"
+    if with_key and publishes and yes:
+        _require_publish_scope(seams, client)
+        return
+    grant = grant_status() if not with_key else {}
+    if grant.get("active"):
+        seams["all_confirmed"] = True
+        if not seams.get("as_json"):
+            until = datetime.fromtimestamp(float(grant["expires_at"])).strftime("%a %d %b, %H:%M")
+            notify(f"Confirmed by your agent grant (until {until}).")
+        return
+    if is_interactive(ctx):
+        _ask(seams, summary, record=not with_key)
+        return
+    if with_key and not publishes:
+        return
+    raise CliError(ExitCode.CONFIRMATION_REQUIRED, "confirmation_required", _missing(summary, with_key=with_key))
+
+
+def _missing(summary: str, *, with_key: bool) -> str:
+    if with_key:
+        return f"{summary} Nothing was sent: re-run with --yes, using an API key that has the publish scope."
+    return (f"{summary} Nothing was sent: this needs your confirmation. Run it in a terminal and answer, or run "
+            "`recala grant` once so agents can write with this sign-in. (--yes works only with an API key that "
+            "has the publish scope.)")
+
+
+def _require_publish_scope(seams: dict[str, Any], client: RecalaClient | None) -> None:
+    scopes = seams.get("key_scopes")
+    if scopes is None and client is not None:
+        me = client.call(ME) or {}
+        scopes = set((me.get("credential") or {}).get("scopes") or [])
+        seams["key_scopes"] = scopes
+    if PUBLISH_SCOPE not in (scopes or set()):
+        raise CliError(ExitCode.CONFIRMATION_REQUIRED, "yes_needs_publish_scope",
+                       "--yes is accepted only from an API key with the publish scope, and this key does not hold "
+                       "it. Nothing was sent.")
+
+
+def _ask(seams: dict[str, Any], summary: str, *, record: bool) -> None:
+    answer = "no"
+    for _ in range(_ATTEMPTS):
+        raw = click.prompt(f"  {summary}  [y]es / [n]o / [a]ll", default="", show_default=False, err=True)
+        if raw.strip().lower() in _ANSWERS:
+            answer = _ANSWERS[raw.strip().lower()]
+            break
+    if answer == "no":
+        raise CliError(ExitCode.CONFIRMATION_REQUIRED, "declined", "Not done: you answered no. Nothing was sent.")
+    if answer == "all":
+        seams["all_confirmed"] = True
+        if record and auth.session_id():
+            record_grant()
+            notify(f"  Confirmed: every write for this sign-in (until logout or {GRANT_HOURS} hours). "
+                   "`recala grant --revoke` undoes it.")

recala_cli/display.py

@@ -0,0 +1,40 @@
+"""Untrusted terminal text, sanitized before Click can render it."""
+
+import re
+import unicodedata
+from typing import Any
+
+_ESCAPES = re.compile(
+    r"(?:\x1b\]|\x9d).*?(?:\x07|\x1b\\|\x9c|$)"
+    r"|(?:\x1b[P^_X]|[\x90\x98\x9e\x9f]).*?(?:\x1b\\|\x9c|$)"
+    r"|(?:\x1b\[|\x9b)[0-?]*[ -/]*[@-~]"
+    r"|\x1b[ -/]*[@-~]",
+    re.DOTALL,
+)
+
+
+def terminal_text(value: str, *, keep_layout: bool = False) -> str:
+    """Remove terminal commands and Unicode controls, including bidi overrides."""
+    text = _ESCAPES.sub("", value)
+    return "".join(
+        ch if not unicodedata.category(ch).startswith("C") or (keep_layout and ch in "\n\t")
+        else " " if ch.isspace() else ""
+        for ch in text
+    )
+
+
+def display_name(value: Any) -> str:
+    return " ".join(terminal_text(value).split()) if isinstance(value, str) else ""
+
+
+def human_data(value: Any, *, field: str = "") -> Any:
+    """A sanitized presentation copy; the API data still goes unchanged to JSON."""
+    if isinstance(value, str):
+        if field in ("name", "display_name", "article_title", "title", "topic", "filename", "company", "author_name"):
+            return display_name(value)
+        return terminal_text(value, keep_layout=field in ("markdown", "markdown_content"))
+    if isinstance(value, dict):
+        return {terminal_text(str(key)): human_data(item, field=str(key)) for key, item in value.items()}
+    if isinstance(value, list):
+        return [human_data(item, field=field) for item in value]
+    return value

recala_cli/endpoints.py

@@ -0,0 +1,258 @@
+"""Every API route the CLI calls, in one table.
+
+apps/api/tests/test_cli_calls_only_routes_the_api_serves.py reads this table
+against the live FastAPI app: a live endpoint must be served with its method, and
+a ``planned`` one must not exist yet. Commands never spell a path inline.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from urllib.parse import quote
+
+
+@dataclass(frozen=True)
+class Endpoint:
+    method: str
+    path: str
+    planned: bool = False  # designed (DESIGN.md) but not in the API yet
+    changes_nothing: bool = False  # a POST that only prices, signs in or polls: no answer means "try again"
+
+    @property
+    def writes(self) -> bool:
+        return self.method != "GET" and not self.changes_nothing
+
+    def url_path(self, **params: str) -> str:
+        return self.path.format(**{name: quote(value, safe="") for name, value in params.items()})
+
+
+ORG_SHOW = Endpoint("GET", "/api/v1/orgs/{org_id}")
+BILLING_CREDIT_SUMMARY = Endpoint("GET", "/api/v1/billing/credits/summary")
+BILLING_CREDITS = Endpoint("GET", "/api/v1/billing/credits")
+BILLING_SUBSCRIPTION = Endpoint("GET", "/api/v1/billing/subscription")
+BILLING_MANAGED_USAGE = Endpoint("GET", "/api/v1/billing/managed-usage")
+BILLING_PAY_LINK = Endpoint("POST", "/api/v1/billing/subscription/pay-link")
+TOPICS_LIST = Endpoint("GET", "/api/v1/content-queue")
+
+ME = Endpoint("GET", "/api/v1/me")
+DEVICE_START = Endpoint("POST", "/api/v1/cli/device", changes_nothing=True)
+DEVICE_TOKEN = Endpoint("POST", "/api/v1/cli/device/token", changes_nothing=True)
+TOKEN_REFRESH = Endpoint("POST", "/api/v1/cli/token/refresh", changes_nothing=True)
+SIGN_OUT = Endpoint("POST", "/api/v1/cli/logout")
+KEYS_LIST = Endpoint("GET", "/api/v1/keys")
+KEYS_CREATE = Endpoint("POST", "/api/v1/keys")
+KEY_REVOKE = Endpoint("DELETE", "/api/v1/keys/{key_id}")
+KEY_EVENTS = Endpoint("GET", "/api/v1/keys/{key_id}/events")
+
+# Slice 3: content verbs.
+ARTICLES_LIST = Endpoint("GET", "/api/v1/articles")
+ARTICLE_SHOW = Endpoint("GET", "/api/v1/articles/{article_id}")
+ARTICLE_VERSIONS = Endpoint("GET", "/api/v1/articles/{article_id}/versions")
+ARTICLE_VERSION = Endpoint("GET", "/api/v1/articles/{article_id}/versions/{number}")
+ARTICLE_BODY = Endpoint("PATCH", "/api/v1/articles/{article_id}/body")
+ARTICLE_REDRAFT_START = Endpoint("POST", "/api/v1/articles/{article_id}/redraft")
+ARTICLE_REDRAFT_LATEST = Endpoint("GET", "/api/v1/articles/{article_id}/redraft")
+ARTICLE_REDRAFT_APPLY = Endpoint("POST", "/api/v1/articles/{article_id}/redraft/{redraft_id}/apply")
+ARTICLE_PERSON = Endpoint("POST", "/api/v1/articles/{article_id}/person")
+ARTICLE_SUBMIT = Endpoint("POST", "/api/v1/articles/{article_id}/submit-review")
+ARTICLE_REQUEST_CHANGES = Endpoint("POST", "/api/v1/articles/{article_id}/request-changes")
+ARTICLE_COMMENTS = Endpoint("GET", "/api/v1/articles/{article_id}/review-comments")
+REVIEW_LINK_SHOW = Endpoint("GET", "/api/v1/articles/{article_id}/review-link")
+REVIEW_LINK_CREATE = Endpoint("POST", "/api/v1/articles/{article_id}/review-link")
+REVIEW_LINK_REVOKE = Endpoint("DELETE", "/api/v1/articles/{article_id}/review-link")
+SHARE_TOKEN_ROTATE = Endpoint("POST", "/api/v1/articles/{article_id}/rotate-share-token")
+TOPIC_ADD = Endpoint("POST", "/api/v1/content-queue")
+TOPIC_DISMISS = Endpoint("POST", "/api/v1/content-queue/{queue_id}/dismiss")
+TOPIC_APPROVE = Endpoint("POST", "/api/v1/content-queue/{queue_id}/approve")
+TOPIC_WHY = Endpoint("GET", "/api/v1/content-queue/{item_id}/rationale")
+KNOWLEDGE_LIST = Endpoint("GET", "/api/v1/knowledge/documents")
+KNOWLEDGE_UPLOAD = Endpoint("POST", "/api/v1/knowledge/upload")
+KNOWLEDGE_URL = Endpoint("POST", "/api/v1/knowledge/extract-url")
+KNOWLEDGE_URLS = Endpoint("POST", "/api/v1/knowledge/extract-urls")
+KNOWLEDGE_REMOVE = Endpoint("DELETE", "/api/v1/knowledge/documents/{doc_id}")
+KNOWLEDGE_PAGE = Endpoint("GET", "/api/v1/knowledge/documents/{doc_id}/page")
+PEOPLE_LIST = Endpoint("GET", "/api/v1/people")
+CALENDAR = Endpoint("GET", "/api/v1/publication-calendar")
+AUTHORITY_SCORE = Endpoint("GET", "/api/v1/authority-score")
+
+# Slice 4: approving, publishing, spending, connecting.
+ARTICLE_APPROVE = Endpoint("POST", "/api/v1/articles/{article_id}/approve")
+ARTICLE_UNPUBLISH = Endpoint("POST", "/api/v1/articles/{article_id}/unpublish")
+ARTICLE_REPUBLISH = Endpoint("POST", "/api/v1/articles/{article_id}/republish")
+ARTICLE_READINESS = Endpoint("GET", "/api/v1/articles/{article_id}/publication-readiness")
+APPOINTMENT_BOOK = Endpoint("PUT", "/api/v1/articles/{article_id}/publication-appointment")
+APPOINTMENT_CANCEL = Endpoint("DELETE", "/api/v1/articles/{article_id}/publication-appointment")
+COST_PREVIEW = Endpoint("POST", "/api/v1/cost-previews", changes_nothing=True)
+GENERATE_FROM_TOPIC = Endpoint("POST", "/api/v1/generate/from-queue/{queue_id}")
+BILLING_SPEND = Endpoint("GET", "/api/v1/billing/spend")
+CMS_STATUS = Endpoint("GET", "/api/v1/cms/status")
+GSC_STATUS = Endpoint("GET", "/api/v1/gsc/status")
+GSC_SERVICE_ACCOUNT = Endpoint("GET", "/api/v1/gsc/service-account")
+GSC_SERVICE_ACCOUNT_CHECK = Endpoint("POST", "/api/v1/gsc/service-account/check")
+GSC_PERFORMANCE = Endpoint("GET", "/api/v1/gsc/performance")
+BING_STATUS = Endpoint("GET", "/api/v1/bing/status")
+BING_SITES = Endpoint("GET", "/api/v1/bing/sites")
+BING_SITE = Endpoint("PUT", "/api/v1/bing/site")
+BING_PERFORMANCE = Endpoint("GET", "/api/v1/bing/performance")
+
+# Onboarding from the terminal: the routes the portal's wizard, Settings and billing pages call.
+ORG_CREATE = Endpoint("POST", "/api/v1/orgs")
+ORG_UPDATE = Endpoint("PATCH", "/api/v1/orgs/{org_id}")
+ONBOARDING_SCRAPE = Endpoint("POST", "/api/v1/onboarding/scrape")
+ONBOARDING_SAVE = Endpoint("POST", "/api/v1/onboarding/save-entities")
+ONBOARDING_COMPLETE = Endpoint("POST", "/api/v1/onboarding/complete")
+PERSON_CREATE = Endpoint("POST", "/api/v1/people")
+PERSON_UPDATE = Endpoint("PATCH", "/api/v1/people/{person_id}")
+KNOWLEDGE_ADMIT = Endpoint("POST", "/api/v1/knowledge/documents/{doc_id}/admit")
+SANITY_STATUS = Endpoint("GET", "/api/v1/cms/sanity/status")
+SANITY_CONNECT = Endpoint("POST", "/api/v1/cms/sanity/connect")
+WORDPRESS_VERIFY = Endpoint("POST", "/api/v1/wordpress/verify", changes_nothing=True)
+WORDPRESS_CONNECT = Endpoint("POST", "/api/v1/wordpress/connect")
+GSC_PROPERTIES = Endpoint("GET", "/api/v1/gsc/properties")
+GSC_PROPERTY = Endpoint("PUT", "/api/v1/gsc/property")
+CREDITS_SUMMARY = Endpoint("GET", "/api/v1/billing/credits/summary")
+ENTITLEMENTS = Endpoint("GET", "/api/v1/billing/entitlements")
+QUESTION_PANEL = Endpoint("GET", "/api/v1/question-panel")
+QUESTION_PANEL_BASELINE = Endpoint("POST", "/api/v1/question-panel/baseline")
+
+# Indexing routes are served by main; feature flags can still return 404 at runtime.
+INDEXING_SITEMAPS = Endpoint("GET", "/api/v1/indexing/sitemaps")
+INDEXING_SITEMAPS_SUBMIT = Endpoint("POST", "/api/v1/indexing/sitemaps/submit")
+ARTICLE_INDEXING = Endpoint("GET", "/api/v1/articles/{article_id}/indexing")
+ARTICLE_INDEXING_SUBMIT = Endpoint("POST", "/api/v1/articles/{article_id}/indexing/submit")
+
+TOPICS_SCOUT = Endpoint("POST", "/api/v1/topics/scout")
+TOPICS_SCOUT_STATUS = Endpoint("GET", "/api/v1/topics/scout/status")
+
+CADENCE_SHOW = Endpoint("GET", "/api/v1/publication-cadence")
+CADENCE_SET = Endpoint("PUT", "/api/v1/publication-cadence")
+AUTOAPPROVE_SHOW = Endpoint("GET", "/api/v1/orgs/current/auto-approve")
+AUTOAPPROVE_SET = Endpoint("PUT", "/api/v1/orgs/current/auto-approve")
+FAITHFUL_TRANSLATIONS_SHOW = Endpoint(
+    "GET", "/api/v1/orgs/current/auto-approve/faithful-translations"
+)
+FAITHFUL_TRANSLATIONS_SET = Endpoint(
+    "PUT", "/api/v1/orgs/current/auto-approve/faithful-translations"
+)
+PUBLICATION_PLAN = Endpoint("GET", "/api/v1/publication-plan")
+ESCALATED_SLOTS = Endpoint("GET", "/api/v1/publication-slots/escalated")
+SLOT_TOPIC_REPLACE = Endpoint("POST", "/api/v1/publication-slots/{slot_id}/topic")
+
+GENERATION_STATUS = Endpoint("GET", "/api/v1/runs/{queue_id}")
+ARTICLE_REGENERATE = Endpoint("POST", "/api/v1/articles/{article_id}/regenerate")
+ARTICLE_RECHECK = Endpoint("POST", "/api/v1/articles/{article_id}/recheck")
+UP_NEXT_ADD = Endpoint("POST", "/api/v1/up-next/add")
+UP_NEXT_REMOVE = Endpoint("POST", "/api/v1/up-next/remove")
+UP_NEXT_REORDER = Endpoint("POST", "/api/v1/up-next/reorder")
+
+# 0.6.0: what the portal does that the terminal could not.
+LANGUAGES_SHOW = Endpoint("GET", "/api/v1/org-settings/languages")
+LANGUAGES_SET = Endpoint("PATCH", "/api/v1/org-settings/languages")
+NOTIFICATIONS_LIST = Endpoint("GET", "/api/v1/notifications")
+NOTIFICATION_READ = Endpoint("POST", "/api/v1/notifications/{notification_id}/read")
+NOTIFICATIONS_READ_ALL = Endpoint("POST", "/api/v1/notifications/read-all")
+REPORT_MONTHLY = Endpoint("GET", "/api/v1/reports/monthly")
+REPORT_SHARES = Endpoint("GET", "/api/v1/reports/monthly/shares")
+REPORT_SHARE_CREATE = Endpoint("POST", "/api/v1/reports/monthly/share")
+REFRESH_SUMMARY = Endpoint("GET", "/api/v1/billing/refresh-summary")
+ARTICLE_AUTO_REFRESH = Endpoint("PATCH", "/api/v1/articles/{article_id}/auto-refresh")
+REFRESH_STATUS = Endpoint("GET", "/api/v1/refreshes/{refresh_id}/status")
+PROFILE_AUTHOR = Endpoint("GET", "/api/v1/author")
+PROFILE_POSITIONING = Endpoint("GET", "/api/v1/org-profile/positioning")
+PROFILE_INTENT = Endpoint("GET", "/api/v1/intent")
+BILLING_INVOICES = Endpoint("GET", "/api/v1/billing/invoices")
+
+ALL_ENDPOINTS = (
+    LANGUAGES_SHOW, LANGUAGES_SET, NOTIFICATIONS_LIST, NOTIFICATION_READ, NOTIFICATIONS_READ_ALL,
+    REPORT_MONTHLY, REPORT_SHARES, REPORT_SHARE_CREATE, REFRESH_SUMMARY, ARTICLE_AUTO_REFRESH, REFRESH_STATUS,
+    PROFILE_AUTHOR, PROFILE_POSITIONING, PROFILE_INTENT, BILLING_INVOICES,
+    GENERATION_STATUS, ARTICLE_REGENERATE, ARTICLE_RECHECK,
+    UP_NEXT_ADD, UP_NEXT_REMOVE, UP_NEXT_REORDER,
+    TOPICS_SCOUT,
+    TOPICS_SCOUT_STATUS,
+    CADENCE_SHOW, CADENCE_SET, AUTOAPPROVE_SHOW, AUTOAPPROVE_SET, PUBLICATION_PLAN,
+    ESCALATED_SLOTS, SLOT_TOPIC_REPLACE,
+    FAITHFUL_TRANSLATIONS_SHOW, FAITHFUL_TRANSLATIONS_SET,
+    ORG_SHOW,
+    BILLING_CREDITS,
+    BILLING_CREDIT_SUMMARY,
+    BILLING_SUBSCRIPTION,
+    BILLING_MANAGED_USAGE,
+    TOPICS_LIST,
+    ME,
+    DEVICE_START,
+    DEVICE_TOKEN,
+    TOKEN_REFRESH,
+    SIGN_OUT,
+    KEYS_LIST,
+    KEYS_CREATE,
+    KEY_REVOKE,
+    KEY_EVENTS,
+    ARTICLES_LIST,
+    ARTICLE_SHOW,
+    ARTICLE_VERSIONS,
+    ARTICLE_VERSION,
+    ARTICLE_BODY,
+    ARTICLE_REDRAFT_START,
+    ARTICLE_REDRAFT_LATEST,
+    ARTICLE_REDRAFT_APPLY,
+    ARTICLE_PERSON,
+    ARTICLE_SUBMIT,
+    ARTICLE_REQUEST_CHANGES,
+    ARTICLE_COMMENTS,
+    REVIEW_LINK_SHOW,
+    REVIEW_LINK_CREATE,
+    REVIEW_LINK_REVOKE,
+    SHARE_TOKEN_ROTATE,
+    TOPIC_ADD,
+    TOPIC_DISMISS,
+    TOPIC_APPROVE,
+    TOPIC_WHY,
+    KNOWLEDGE_LIST,
+    KNOWLEDGE_UPLOAD,
+    KNOWLEDGE_URL,
+    KNOWLEDGE_URLS,
+    KNOWLEDGE_REMOVE,
+    KNOWLEDGE_PAGE,
+    PEOPLE_LIST,
+    CALENDAR,
+    AUTHORITY_SCORE,
+    ARTICLE_APPROVE,
+    ARTICLE_UNPUBLISH,
+    ARTICLE_REPUBLISH,
+    ARTICLE_READINESS,
+    APPOINTMENT_BOOK,
+    APPOINTMENT_CANCEL,
+    COST_PREVIEW,
+    GENERATE_FROM_TOPIC,
+    BILLING_SPEND,
+    CMS_STATUS,
+    GSC_STATUS,
+    GSC_SERVICE_ACCOUNT,
+    GSC_SERVICE_ACCOUNT_CHECK,
+    GSC_PERFORMANCE,
+    BING_STATUS,
+    BING_PERFORMANCE,
+    ORG_CREATE,
+    ORG_UPDATE,
+    ONBOARDING_SCRAPE,
+    ONBOARDING_SAVE,
+    ONBOARDING_COMPLETE,
+    PERSON_CREATE,
+    PERSON_UPDATE,
+    KNOWLEDGE_ADMIT,
+    SANITY_STATUS,
+    SANITY_CONNECT,
+    WORDPRESS_VERIFY,
+    WORDPRESS_CONNECT,
+    GSC_PROPERTIES,
+    GSC_PROPERTY,
+    CREDITS_SUMMARY,
+    ENTITLEMENTS,
+    QUESTION_PANEL,
+    QUESTION_PANEL_BASELINE,
+    INDEXING_SITEMAPS,
+    INDEXING_SITEMAPS_SUBMIT,
+    ARTICLE_INDEXING,
+    ARTICLE_INDEXING_SUBMIT,
+)