failproofai 1.0.1 → 1.0.2-beta.0

package/.next/standalone/fp-cloud-cli/fp_cli/select.py

@@ -0,0 +1,322 @@
+"""Interactive selection helpers (TTY pickers), shared across commands.
+
+Kept in one place so the org picker used at ``login`` and at ``orgs switch`` reads
+and behaves identically. Pure presentation + input; no network, no persistence.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import List, Optional, Sequence
+
+from . import output
+
+
+def stdin_is_tty() -> bool:  # noqa: D401
+    """True iff stdin is an interactive terminal (so we may prompt for a choice).
+
+    Factored out so it can be stubbed in tests — the CliRunner's stdin is not a
+    TTY, so the interactive pickers are otherwise unreachable under test.
+    """
+    try:
+        return sys.stdin.isatty()
+    except Exception:
+        return False
+
+
+def choose_org(slugs: Sequence[str], default: Optional[str] = None) -> str:
+    """Render ``slugs`` and prompt until the user picks one (by slug or number).
+
+    ``default`` (only if it is one of ``slugs``) is the Enter-to-keep choice and is
+    marked ``· current`` in the list. Re-prompts on any out-of-range / unknown input,
+    so the return value is always one of ``slugs`` — a non-member slug can never be
+    selected through the picker.
+    """
+    slugs = list(slugs)
+    output.org_picker(slugs, current=default)
+    prompt_default = default if (default in slugs) else None
+    while True:
+        choice = str(output.prompt("org", default=prompt_default)).strip()
+        if choice in slugs:
+            return choice
+        if choice.isdigit() and 1 <= int(choice) <= len(slugs):
+            return slugs[int(choice) - 1]
+        output.warn(f"  '{choice}' is not one of your orgs — try again.")
+
+
+# ── orgs switch — arrow-key picker (raw mode) + numbered fallback ─────────────
+
+
+def _supports_raw_picker() -> bool:
+    """True iff we can run the raw-mode arrow picker: a real interactive TTY on both stdin
+    (we read keys) and stderr (we draw the menu), and POSIX ``termios`` is importable.
+    Anything else — pipes, CI, the test runner, Windows — falls back to the numbered prompt
+    (so the picker never hangs or crashes off a TTY, per the handoff spec §3/§7)."""
+    try:
+        import termios  # noqa: F401
+    except Exception:
+        return False
+    try:
+        return bool(sys.stdin.isatty() and sys.stderr.isatty())
+    except Exception:
+        return False
+
+
+def _read_key(fd: int) -> str:
+    """Read one logical keypress from a raw-mode ``fd`` → a token: ``UP``/``DOWN``/``ENTER``/
+    ``ESC``/``EOF`` or the raw character. Distinguishes a lone Esc from an arrow escape
+    sequence (``\\x1b[A``) with a tiny ``select`` timeout so Esc never blocks."""
+    import select as _sel
+
+    ch = os.read(fd, 1)
+    if not ch:
+        return "EOF"
+    if ch == b"\x1b":  # Esc, or the start of an arrow escape sequence
+        r, _, _ = _sel.select([fd], [], [], 0.0008)
+        if not r:
+            return "ESC"
+        seq = os.read(fd, 2)
+        return {b"[A": "UP", b"[B": "DOWN", b"[C": "RIGHT", b"[D": "LEFT"}.get(seq, "ESC")
+    if ch in (b"\r", b"\n"):
+        return "ENTER"
+    if ch == b"\x03":  # Ctrl-C (also raised as KeyboardInterrupt under cbreak)
+        return "CTRL_C"
+    return ch.decode("utf-8", "ignore")
+
+
+def _numbered_pick(orgs: Sequence[dict], *, current: Optional[str]) -> str:
+    """Non-TTY fallback: a boxed numbered list + a typed choice (slug or number). Re-prompts on
+    bad input, so the return is always one of the orgs' slugs. Default is the current org. With
+    no input at all (closed/empty stdin, e.g. CI) the prompt aborts → a clean usage error so the
+    run never hangs."""
+    import typer
+
+    from . import _click_compat as click  # the Click Typer is running
+
+    slugs: List[str] = [o["slug"] for o in orgs]
+    output.render_org_picker_numbered(orgs, current=current)
+    default = current if current in slugs else None
+    while True:
+        try:
+            choice = str(output.prompt("org", default=default)).strip()
+        except (click.Abort, EOFError):
+            raise typer.BadParameter(
+                "No org selected and no interactive terminal. "
+                "Pass a slug, e.g. `fp orgs switch <slug>`."
+            )
+        if choice in slugs:
+            return choice
+        if choice.isdigit() and 1 <= int(choice) <= len(slugs):
+            return slugs[int(choice) - 1]
+        output.warn(f"  '{choice}' is not one of your orgs — try again.")
+
+
+def choose_org_interactive(orgs: Sequence[dict], *, current_slug: Optional[str] = None) -> Optional[str]:
+    """Pick an org to switch to. ``orgs`` is a list of ``{"slug", "is_current"}`` dicts. Returns
+    the chosen slug, or ``None`` if the user cancelled (Esc / Ctrl-C). On a real TTY this is an
+    in-place arrow-key menu (cursor starts on the current org); otherwise it falls back to a
+    numbered prompt (which can't cancel — it always returns a slug)."""
+    orgs = list(orgs)
+    if not _supports_raw_picker():
+        return _numbered_pick(orgs, current=current_slug)
+
+    import termios
+    import tty
+
+    from rich.live import Live
+
+    idx = next((i for i, o in enumerate(orgs) if o.get("is_current")), 0)
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        with Live(output.org_picker_frame(orgs, idx), console=output._stderr,
+                  auto_refresh=False, transient=True) as live:
+            while True:
+                key = _read_key(fd)
+                if key in ("UP", "k"):
+                    idx = (idx - 1) % len(orgs)
+                elif key in ("DOWN", "j"):
+                    idx = (idx + 1) % len(orgs)
+                elif key == "ENTER":
+                    return orgs[idx]["slug"]
+                elif key in ("ESC", "CTRL_C", "q", "EOF"):
+                    return None
+                else:
+                    continue
+                live.update(output.org_picker_frame(orgs, idx))
+                live.refresh()
+    except KeyboardInterrupt:
+        return None
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+
+# ── login — the single-box interactive flow (one Live panel, raw-mode in-box input) ──
+
+
+class LoginCancelled(Exception):
+    """The user pressed Esc / Ctrl-C during the login flow (calm cancel, not an error)."""
+
+
+def login_box_supported() -> bool:
+    """True iff the single-box interactive login can run (real TTY on stdin+stderr + termios) —
+    otherwise ``login`` uses the plain prompt flow (tests, pipes, CI, ``--json``)."""
+    return _supports_raw_picker()
+
+
+class LoginBox:
+    """Drives the single-box ``login``: ONE Rich ``Live`` panel redrawn in place as steps advance.
+    email/code are read in **raw mode** (echo off) and rendered INSIDE the frame; the org step is the
+    shared arrow picker as a nested inset. Restores the terminal on exit. Used only on a real TTY —
+    the non-interactive path keeps the plain prompts."""
+
+    def __init__(self) -> None:
+        self.done: List = []      # collapsed ✓ steps: (label, value)
+        self.active: Optional[str] = None
+        self._fd = sys.stdin.fileno()
+        self._old = None
+        self._live = None
+
+    def __enter__(self) -> "LoginBox":
+        import termios
+        import tty
+
+        from rich.live import Live
+
+        self._old = termios.tcgetattr(self._fd)
+        tty.setcbreak(self._fd)  # canonical + echo off, signals on (Ctrl-C → KeyboardInterrupt)
+        self._live = Live(output.render_login_frame(self.done, None), console=output._stderr,
+                          auto_refresh=False, transient=False)
+        self._live.__enter__()
+        return self
+
+    def __exit__(self, *exc) -> None:
+        import termios
+
+        try:
+            if self._live is not None:
+                self._live.__exit__(*exc)
+        finally:
+            termios.tcsetattr(self._fd, termios.TCSADRAIN, self._old)
+
+    def _draw(self, **kw) -> None:
+        self._live.update(output.render_login_frame(self.done, self.active, **kw))
+        self._live.refresh()
+
+    def _read_line(self, *, helper, slots, error) -> str:
+        """Read one line in raw mode, redrawing the frame on every keystroke so the typed text
+        appears INSIDE the box (echo is off). Backspace edits; Enter accepts; Esc / Ctrl-C / EOF
+        cancel (an arrow escape-sequence mid-type is swallowed, not a cancel). A ``slots`` field
+        accepts digits only, capped at ``slots``."""
+        import select as _sel
+
+        buf = ""
+        self._draw(active_value=buf, active_slots=slots, helper=helper, error=error)
+        while True:
+            try:
+                ch = os.read(self._fd, 1)
+            except KeyboardInterrupt:
+                raise LoginCancelled()
+            if not ch:
+                raise LoginCancelled()
+            if ch in (b"\r", b"\n"):
+                return buf
+            if ch == b"\x03":  # Ctrl-C as a byte (if signals were off)
+                raise LoginCancelled()
+            if ch == b"\x1b":  # Esc, or the start of an arrow escape sequence
+                r, _, _ = _sel.select([self._fd], [], [], 0.0008)
+                if r:
+                    os.read(self._fd, 2)  # swallow the arrow/sequence — don't cancel mid-type
+                    continue
+                raise LoginCancelled()
+            if ch in (b"\x7f", b"\x08"):  # backspace / delete
+                buf = buf[:-1]
+                self._draw(active_value=buf, active_slots=slots, helper=helper, error=None)
+                continue
+            try:
+                c = ch.decode("utf-8")
+            except UnicodeDecodeError:
+                continue
+            if not c.isprintable():
+                continue
+            if slots and (not c.isdigit() or len(buf) >= slots):
+                continue  # the code field is digits-only, capped
+            buf += c
+            self._draw(active_value=buf, active_slots=slots, helper=helper, error=None)
+
+    def text_step(self, label: str, *, helper=None, slots=None, validate=None,
+                  error_msg=None, hidden_value: bool = False, collapse: bool = True,
+                  initial_error=None) -> str:
+        """Run one bright ``❯ {label}`` input step; on a failed ``validate`` show the error sub-line
+        and re-prompt. On accept it collapses to a dim ``✓ {label} {value}`` line (the value is
+        omitted when ``hidden_value``). With ``collapse=False`` it returns the value WITHOUT adding
+        the ✓ line (the caller verifies it over the network first, then calls ``note``); ``initial_error``
+        seeds the error sub-line on the first draw (a re-prompt after a wrong code)."""
+        self.active = label
+        error = initial_error
+        while True:
+            buf = self._read_line(helper=helper, slots=slots, error=error).strip()
+            if validate is None or validate(buf):
+                self.active = None
+                if collapse:
+                    self.done.append((label, "" if hidden_value else buf))
+                self._draw()
+                return buf
+            error = error_msg or "that doesn't look right"
+
+    def note(self, label: str, value=None) -> None:
+        """Add a completed ✓ line that wasn't an input step (e.g. ``✓ code sent``)."""
+        self.done.append((label, value))
+        self._draw()
+
+    def working(self, text: str) -> None:
+        """Show a transient dim ``· {text}`` line (e.g. while a network call runs)."""
+        self._draw(note=text)
+
+    def retry_text(self, message: str) -> None:
+        """Re-arm the code step with an error sub-line (used after a wrong code)."""
+        # text_step's own loop shows the error; this is for the verify-fail re-prompt path.
+        self._draw(error=message)
+
+    def pick(self, slugs: Sequence[str], *, default: Optional[str] = None) -> str:
+        """The nested org-picker inset: arrow keys move the cursor, Enter selects (collapses to
+        ``✓ org {slug}``), Esc / Ctrl-C raise ``LoginCancelled``."""
+        slugs = list(slugs)
+        idx = slugs.index(default) if default in slugs else 0
+        self.active = None
+        self._draw(inset=output.login_inset(slugs, idx))
+        while True:
+            try:
+                key = _read_key(self._fd)
+            except KeyboardInterrupt:
+                raise LoginCancelled()
+            if key in ("UP", "k"):
+                idx = (idx - 1) % len(slugs)
+            elif key in ("DOWN", "j"):
+                idx = (idx + 1) % len(slugs)
+            elif key == "ENTER":
+                chosen = slugs[idx]
+                self.done.append(("org", chosen))
+                self._draw()
+                return chosen
+            elif key in ("ESC", "CTRL_C", "q", "EOF"):
+                raise LoginCancelled()
+            else:
+                continue
+            self._draw(inset=output.login_inset(slugs, idx))
+
+    def finish(self, email: str, org: Optional[str]) -> None:
+        """Final state: the outer border + legend flip SUCCESS green; ``● signed in`` + email + org."""
+        self._draw(signed_in=(email, org))
+
+    def cancel(self, persisted: bool) -> None:
+        """Render the calm close — ``○ cancelled — not signed in`` (or ``○ signed in · pick an org …``
+        when the session was already persisted)."""
+        self._draw(cancelled=bool(persisted))
+
+    def fail(self, message: str, hint: Optional[str] = None) -> None:
+        """Render a failure INSIDE the box (red border + ``✗ {message}`` + an optional hint) — e.g.
+        a wrong/expired code — instead of a separate error box below the frame."""
+        self._draw(failed=(message, hint))

package/.next/standalone/fp-cloud-cli/fp_cli/theme.py

@@ -0,0 +1,53 @@
+"""Shared brand color tokens + the permission action→color map.
+
+Truecolor hex; Rich downgrades to the nearest supported color automatically and drops color
+entirely under ``NO_COLOR`` / non-color terminals.
+"""
+
+from __future__ import annotations
+
+ACCENT = "#9d7bff"    # brand mark, box borders, active org, command names in hints
+TEXT = "#d8d2dd"      # primary values
+TEXT_DIM = "#7d7488"  # ids, resource names, org names
+LABEL = "#6b6478"     # field labels, header cells, hints
+FAINT = "#5a5266"     # separators, inactive markers
+THIN_RULE = "#2e2435" # the faint rule beneath a list-panel header
+BAR_EMPTY = "#2a2530" # the unfilled cells of a mini-bar (e.g. the aggregate avg bar)
+INSET_BG = "#231e2d"  # a hair-lighter fill for a nested inset box (the login org picker)
+
+# Errors theme — the one per-command border deviation (the `errors` list + aggregate card).
+# Always red, regardless of error count, so the two views read as one consistent family.
+BORDER_ERROR = "#e2564a"  # red → the errors panel border (same as ERROR; consistent, not count-dependent)
+TITLE_ERROR_DIM = "#6e3530"  # dim red → the errors title's non-name part + card separators
+RULE_ERROR = "#3a2d2d"  # dim red → the errors list header rule (vs the neutral THIN_RULE)
+
+# Semantic value colors — for run/job states and score thresholds. (They coincide with
+# the perm risk colors below; named separately so the two uses can diverge later.)
+SUCCESS = "#5dcaa5"   # green     → run status: done/passed
+AMBER = "#ef9f27"     # amber     → run status: running/pending · score band .50–.80
+ERROR = "#e2564a"     # red       → run status: failed/error · score band < .50
+SCORE_HIGH = "#3ddbb8"  # cyan-green → score band ≥ .80 (distinct from status green)
+BLUE = "#6b86d8"      # blue      → schema uuid/timestamp type category
+PINK = "#d4537e"      # pink      → numeric values (query run cells / scalar card) + numeric type category
+
+# Permission verb colors — by ACTION (the part after `:`), never by resource.
+PERM_READ = "#5dcaa5"    # green  → read
+PERM_WRITE = "#d4537e"   # pink   → add, create, write, update
+PERM_ACTION = "#ef9f27"  # amber  → use, trigger, run, ack
+PERM_DANGER = "#e2564a"  # red    → delete, disable, regenerate
+
+PERM_COLORS = {
+    "read": PERM_READ,
+    "add": PERM_WRITE, "create": PERM_WRITE, "write": PERM_WRITE, "update": PERM_WRITE,
+    "use": PERM_ACTION, "trigger": PERM_ACTION, "run": PERM_ACTION, "ack": PERM_ACTION,
+    "delete": PERM_DANGER, "disable": PERM_DANGER, "regenerate": PERM_DANGER,
+}
+DEFAULT_PERM_COLOR = LABEL  # any unmapped action → neutral dim (never crash / guess a risk)
+
+# Risk rank for ordering actions within a row: read → modify → invoke → destroy.
+PERM_RANK = {PERM_READ: 0, PERM_WRITE: 1, PERM_ACTION: 2, PERM_DANGER: 3}
+
+
+def perm_color(action: str) -> str:
+    """The color for a permission action, or the neutral default if it's unmapped."""
+    return PERM_COLORS.get(action, DEFAULT_PERM_COLOR)

package/.next/standalone/fp-cloud-cli/pyproject.toml

@@ -0,0 +1,106 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fp-cloud-cli"
+dynamic = ["version"]
+requires-python = ">=3.10"
+description = "Command line client for FailproofAI Cloud — sessions, events, evaluations and audits from your terminal"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "Failproof AI", email = "failproofai@exosphere.host" }]
+keywords = ["agents", "observability", "ai", "monitoring", "failproofai", "cli"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = [
+    "httpx>=0.27",
+    # This range spans typer's Click split: 0.26 vendored Click into `typer/_click` and
+    # dropped the `click` dependency, so Typer's command runner catches ITS Click's
+    # exceptions, not the pip `click` ones. `fp_cli/_click_compat` resolves whichever
+    # Click the installed typer is running, and everything raises, subclasses and inspects
+    # through that — which is what makes both sides of the split work. Import Click from
+    # there and nowhere else; `tests/test_click_compat.py` enforces it, because every way
+    # this breaks is silent (typed errors collapse to exit 1 with an empty stderr, and the
+    # telemetry flag catalog empties). Suite verified against 0.25.1 and 0.27.0.
+    #
+    # The floor is 0.13, not 0.12, because 0.12 cannot BUILD this app: the global
+    # `--insecure/--secure` option in `app.py` is an `Optional[bool]` with a
+    # secondary flag, which 0.12's Click reaches as a non-boolean flag and
+    # rejects with `TypeError: Secondary flag is not valid for non-boolean flag`.
+    # That fires while the command tree is constructed, before any parsing, so
+    # `fp --version`, `fp --help` and every subcommand die identically — an
+    # installed CLI that cannot run one command. `uv.lock` pins 0.27.1, so
+    # neither CI nor the publish smoke test ever installed the broken part of the
+    # range. Measured across 0.12.0/0.12.3/0.12.5 (all fail) and 0.13.0 upward
+    # (all pass).
+    "typer>=0.13,<0.28",
+    # `click` is what `_click_compat` falls back to when typer is < 0.26 (0.26+ brings its
+    # own), and `pygments` is imported directly. Both are declared rather than relied on
+    # transitively: modern `typer` no longer installs `click`, and `rich` could likewise
+    # drop `pygments`.
+    "click>=8.1",
+    "rich>=13",
+    "pygments>=2.13",
+    "posthog>=3.5,<8",
+]
+
+# The distribution is `fp-cloud-cli`; the command is `fp`; the import package is
+# `fp_cli`. All three differ, and each for its own reason:
+#
+#   `fp`            was already registered on PyPI by someone else.
+#   `fp-cli`        was the next choice and is ALSO unusable: PyPI refuses a name
+#                   "too similar to an existing project", and its similarity check
+#                   strips separators — so `fp-cli` collides with `fpcli`, a real
+#                   package with 42 releases. It is not a squat, so there is no
+#                   PEP 541 claim to make; the name simply is not available.
+#   `fp-cloud-cli`  is what pip resolves, and says what this talks to: the Cloud
+#                   dashboard's API, never the Rust server directly.
+#   `fp_cli`        stays as the import package. Nobody imports it — this is an
+#                   application, not a library, and the console script above is the
+#                   entire public surface — so renaming it would churn every module
+#                   and every test to change a string no user ever types.
+#
+# `~/.failproofai/fpcli/` keeps its name for a harder reason: it is an on-disk
+# contract with `src/hooks/fp-home.ts` (`fpcliDir`/`fpcliAuthFile`), and moving it
+# would sign every existing user out.
+[project.scripts]
+fp = "fp_cli.app:main_entry"
+
+[project.urls]
+Homepage = "https://befailproof.ai"
+# The live route. `/agenteye/cli` is a 404 — those pages moved to `docs-old/`,
+# which the docs build does not publish and `docs/docs.json` does not reference,
+# and there are no `redirects`. PyPI bakes project URLs into published metadata,
+# so a wrong one here needs a version bump to correct.
+Documentation = "https://docs.befailproof.ai/reference/cloud-cli"
+Source = "https://github.com/FailproofAI/failproofai"
+# PyPI gives "Changelog" its own sidebar slot and icon. Without it the only
+# thing a visitor to the project page can read is the README, and there is no
+# route at all from an installed version to what changed in it.
+Changelog = "https://github.com/FailproofAI/failproofai/blob/main/fp-cloud-cli/CHANGELOG.md"
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "respx>=0.21"]
+
+[tool.setuptools.dynamic]
+version = { attr = "fp_cli._version.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["fp_cli*"]
+
+[tool.setuptools.package-data]
+fp_cli = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]