failproofai 1.0.1-beta.1 → 1.0.2-beta.0

package/.next/standalone/fp-cloud-cli/tests/test_multivalue.py

@@ -0,0 +1,183 @@
+"""Multi-value option support.
+
+Covers the reusable `collect_multi` normalizer (repeated flags + comma-separated → one
+flat, trimmed, de-duped, order-preserving list) and its end-to-end wiring on the `events`
+command's `--session-id` / `--env` / `--event-type` / `--agent-id` filters (each serialized
+to a CSV `IN(...)` on the wire, single value back-compatible).
+"""
+
+from __future__ import annotations
+
+import httpx
+import respx
+
+from fp_cli._context import collect_multi
+from fp_cli.app import app
+
+BASE = "http://dash.test"
+
+
+# --- the pure normalizer ----------------------------------------------------
+
+
+def test_collect_multi_single_value():
+    # Always an array internally, even for one value.
+    assert collect_multi(["prod"]) == ["prod"]
+
+
+def test_collect_multi_repeated_flags():
+    assert collect_multi(["prod", "staging"]) == ["prod", "staging"]
+
+
+def test_collect_multi_comma_separated():
+    assert collect_multi(["prod,staging"]) == ["prod", "staging"]
+
+
+def test_collect_multi_repeated_and_comma_combined():
+    assert collect_multi(["prod,staging", "dev"]) == ["prod", "staging", "dev"]
+
+
+def test_collect_multi_trims_whitespace():
+    assert collect_multi(["prod, staging"]) == ["prod", "staging"]
+    assert collect_multi([" prod ", " dev"]) == ["prod", "dev"]
+
+
+def test_collect_multi_drops_empty_from_trailing_comma():
+    assert collect_multi(["prod,"]) == ["prod"]
+    assert collect_multi(["prod,,staging"]) == ["prod", "staging"]
+    assert collect_multi([","]) is None
+
+
+def test_collect_multi_dedup_preserves_first_seen_order():
+    assert collect_multi(["prod", "prod"]) == ["prod"]
+    assert collect_multi(["b", "a", "b", "c", "a"]) == ["b", "a", "c"]
+    assert collect_multi(["prod,staging", "staging,prod"]) == ["prod", "staging"]
+
+
+def test_collect_multi_empty_and_none():
+    assert collect_multi(None) is None
+    assert collect_multi([]) is None
+    assert collect_multi(["", "  "]) is None
+
+
+# --- end-to-end on the events command (what reaches the wire) ---------------
+
+
+def _captured_params(logged_in, runner, argv):
+    """Run `events` with argv and return the query params the CLI sent.
+
+    `events` routes to the light feed (/api/events/summary) by default and to the full feed
+    (/api/events) only when payload is needed (e.g. --session-id). Both accept the identical
+    query surface, so mock BOTH and read params from whichever the CLI actually called.
+    """
+    resp = httpx.Response(200, json={"events": [], "next_cursor": None})
+    light = respx.get(f"{BASE}/api/events/summary").mock(return_value=resp)
+    full = respx.get(f"{BASE}/api/events").mock(return_value=resp)
+    result = runner.invoke(app, argv)
+    assert result.exit_code == 0, result.output
+    route = full if full.called else light
+    return dict(route.calls.last.request.url.params)
+
+
+@respx.mock
+def test_events_env_single_value_unchanged(logged_in, runner):
+    # Backward compatibility: one value serializes to a bare `environment=prod`.
+    params = _captured_params(logged_in, runner, ["events", "--env", "prod"])
+    assert params["environment"] == "prod"
+
+
+@respx.mock
+def test_events_env_repeated_flags_merge(logged_in, runner):
+    # The original failing case: repeated flags must keep BOTH, not last-wins.
+    params = _captured_params(logged_in, runner, ["events", "--env", "prod", "--env", "staging"])
+    assert params["environment"] == "prod,staging"
+
+
+@respx.mock
+def test_events_env_comma_separated(logged_in, runner):
+    params = _captured_params(logged_in, runner, ["events", "--env", "prod,staging"])
+    assert params["environment"] == "prod,staging"
+
+
+@respx.mock
+def test_events_env_combined_and_deduped(logged_in, runner):
+    params = _captured_params(
+        logged_in, runner, ["events", "--env", "prod,staging", "--env", "dev", "--env", "prod"]
+    )
+    assert params["environment"] == "prod,staging,dev"
+
+
+@respx.mock
+def test_events_all_four_filters_multi(logged_in, runner):
+    # session-id / agent-id / event-type / env all become CSV IN(...) on the wire.
+    params = _captured_params(
+        logged_in,
+        runner,
+        [
+            "events",
+            "--session-id", "s1", "--session-id", "s2",
+            "--agent-id", "a1,a2",
+            "--event-type", "tool_use", "--event-type", "tool_result",
+            "--env", "prod",
+        ],
+    )
+    assert params["session_id"] == "s1,s2"
+    assert params["agent_id"] == "a1,a2"
+    assert params["event_type"] == "tool_use,tool_result"
+    assert params["environment"] == "prod"
+
+
+# --- end-to-end on the sessions command (/api/sessions) ---------------------
+
+
+def _captured_session_params(logged_in, runner, argv):
+    """Run `sessions` with argv and return the query params the CLI sent to /api/sessions."""
+    route = respx.get(f"{BASE}/api/sessions").mock(
+        return_value=httpx.Response(200, json={"sessions": [], "next_cursor": None})
+    )
+    result = runner.invoke(app, argv)
+    assert result.exit_code == 0, result.output
+    return dict(route.calls.last.request.url.params)
+
+
+@respx.mock
+def test_sessions_status_repeated_flags_merge(logged_in, runner):
+    # --status was the one that 400'd as multi-value on the old endpoint; now CSV IN.
+    params = _captured_session_params(
+        logged_in, runner, ["sessions", "--status", "error", "--status", "timeout"]
+    )
+    assert params["status"] == "error,timeout"
+
+
+@respx.mock
+def test_sessions_all_four_filters_multi(logged_in, runner):
+    # env / status / agent-id / session-id all become CSV IN(...) on the wire.
+    params = _captured_session_params(
+        logged_in,
+        runner,
+        [
+            "sessions",
+            "--env", "prod,staging",
+            "--status", "done", "--status", "error",
+            "--agent-id", "a1", "--agent-id", "a2",
+            "--session-id", "s1,s2",
+        ],
+    )
+    assert params["environment"] == "prod,staging"
+    assert params["status"] == "done,error"
+    assert params["agent_id"] == "a1,a2"
+    assert params["session_id"] == "s1,s2"
+
+
+@respx.mock
+def test_sessions_single_value_unchanged(logged_in, runner):
+    # Backward compatibility: one value serializes to a bare param.
+    params = _captured_session_params(logged_in, runner, ["sessions", "--env", "prod"])
+    assert params["environment"] == "prod"
+
+
+def test_sessions_bad_status_is_usage_error(logged_in, runner):
+    # An invalid --status value is caught client-side (exit 2), not a server 400.
+    assert runner.invoke(app, ["sessions", "--status", "bogus"]).exit_code == 2
+    # ...even when mixed with a valid one.
+    assert runner.invoke(app, ["sessions", "--status", "done,bogus"]).exit_code == 2

package/.next/standalone/fp-cloud-cli/tests/test_no_customer_identifiers.py

@@ -0,0 +1,168 @@
+"""This package is PUBLIC and its wheel is published to PyPI.
+
+A real customer's tenant slug and company name reached this tree once, in a source
+comment that shipped in the wheel and in four test files. It came across in a bulk
+copy out of a private monorepo, where naming a live tenant in a fixture was harmless.
+
+Fixtures must use obviously-fake names. This is the tripwire.
+
+Customer names are held as SHA-256 digests, never in the clear. A deny-list that
+spells out the name it exists to keep out of a public wheel publishes that name just
+as surely as the fixture did — and this file ships in the sdist. Our OWN names stay
+readable: they are already in LICENSE, SECURITY.md and package.json, so there is
+nothing to withhold, and a contributor who trips over one needs to see which it was.
+
+The match is over SUBSTRINGS of each token, not whole tokens, because the original
+leak was both a bare tenant slug and a longer company name built from that same slug
+— one name inside the other. To add an identifier:
+
+    python3 -c 'import hashlib,sys;print(hashlib.sha256(sys.argv[1].lower().encode()).hexdigest())' NAME
+"""
+
+from __future__ import annotations
+
+import functools
+import hashlib
+import pathlib
+import re
+
+import fp_cli
+
+PKG = pathlib.Path(fp_cli.__file__).resolve().parent
+ROOT = PKG.parent
+
+# Our own organisation names — public in this repo already, so in the clear. A fixture
+# must still not use them: they identify a real tenant on a real deployment.
+FORBIDDEN_OWN = {
+    "exosphere",
+    "exospherehost",
+}
+
+# Customer / vendor identifiers, digest → what it is (never the name itself).
+FORBIDDEN_DIGESTS = {
+    "140bd3c7a8606c97e18fb1f01c3a94f558eab6e2c5b27a56f9c3f5a940d8e2fd": "a customer's tenant slug",
+}
+
+# The vocabulary fixtures are supposed to use.
+SANCTIONED_FIXTURE_ORGS = {"acme", "globex", "example", "initech", "umbrella"}
+
+_TOKEN = re.compile(r"[a-z0-9]+")
+_URL = re.compile(r"https?://([a-z0-9.-]+)", re.I)
+
+# Substring lengths considered when hashing. The floor keeps the scan off two- and
+# three-letter noise; the ceiling bounds the work on long tokens (hex digests, base64).
+_MIN_LEN = 5
+_MAX_LEN = 24
+
+
+@functools.lru_cache(maxsize=None)
+def _digest(text: str) -> str:
+    return hashlib.sha256(text.encode()).hexdigest()
+
+
+def _hashed_hits(text: str, needles: frozenset[str] | None = None) -> set[str]:
+    """Digests from ``needles`` whose plaintext appears anywhere in ``text``.
+
+    ``text`` need not be lowercased by the caller. Returns digests, not matched text:
+    a failure message must not echo the identifier into a public CI log.
+    """
+    want = FORBIDDEN_DIGESTS.keys() if needles is None else needles
+    found = set()
+    for token in set(_TOKEN.findall(text.lower())):
+        for start in range(len(token)):
+            stop = min(len(token), start + _MAX_LEN)
+            for end in range(start + _MIN_LEN, stop + 1):
+                d = _digest(token[start:end])
+                if d in want:
+                    found.add(d)
+    return found
+
+
+def _sources() -> list[pathlib.Path]:
+    out = []
+    for base in (PKG, ROOT / "tests"):
+        out.extend(p for p in base.rglob("*.py") if "__pycache__" not in p.parts)
+    for name in ("README.md", "CHANGELOG.md"):
+        p = ROOT / name
+        if p.is_file():
+            out.append(p)
+    for p in (ROOT / "skill").rglob("*"):
+        if p.is_file() and p.suffix in {".md", ".yaml", ".yml"}:
+            out.append(p)
+    return out
+
+
+def _scannable() -> list[pathlib.Path]:
+    """Everything but this file, which names our own orgs to deny them."""
+    return [p for p in _sources() if p.name != pathlib.Path(__file__).name]
+
+
+def test_no_real_customer_or_vendor_identifiers():
+    hits = []
+    for p in _scannable():
+        for i, line in enumerate(p.read_text(encoding="utf-8", errors="replace").split("\n"), 1):
+            lowered = line.lower()
+            for needle in FORBIDDEN_OWN:
+                if needle in lowered:
+                    hits.append(f"{p.relative_to(ROOT)}:{i}: {needle}")
+            # Report the location and what class of identifier it is — never the name.
+            for digest in _hashed_hits(line):
+                hits.append(f"{p.relative_to(ROOT)}:{i}: {FORBIDDEN_DIGESTS[digest]}")
+    assert not hits, (
+        "real organisation names must not appear in a public package — use a fixture "
+        f"name such as {sorted(SANCTIONED_FIXTURE_ORGS)}:\n  " + "\n  ".join(hits)
+    )
+
+
+def test_the_scan_actually_has_files_to_scan():
+    """Keeps the assertion above from passing vacuously if the layout moves."""
+    files = _sources()
+    assert len(files) > 40, f"only {len(files)} files scanned — the walk is not finding the package"
+
+
+def test_the_hashed_scan_matches_substrings_and_only_them():
+    """The digests are opaque, so prove the matcher on a planted, invented name.
+
+    Without this, an off-by-one in the substring window turns the whole hashed
+    deny-list into an assertion that passes because it matches nothing.
+    """
+    planted = frozenset({_digest("quuxcorp")})
+    assert _hashed_hits("slug: quuxcorp", planted) == planted            # bare token
+    assert _hashed_hits('name: "QuuxcorpInc"', planted) == planted       # inside a longer name
+    assert _hashed_hits("host: quuxcorp-prod.example.com", planted) == planted
+    assert not _hashed_hits("slug: acme, name: Globex Corp", planted)    # sanctioned fixtures
+    assert not _hashed_hits("quux corp", planted)                        # not one token
+
+
+def test_this_file_does_not_name_the_customers_it_denies():
+    """The deny-list must not restate, in the clear, what it holds as a digest.
+
+    ``_scannable()`` skips this file so the ``FORBIDDEN_OWN`` literals above do not
+    trip the scan on themselves. That exemption is about OUR names, which are public
+    in this repo already. It must never extend to a customer's: this file ships in
+    the sdist, so a name written here is published exactly like the fixture that
+    started all this. It needs its own test precisely because the exemption is what
+    blinds the main scan to it.
+    """
+    src = pathlib.Path(__file__)
+    hits = [
+        f"{src.name}:{i}: {FORBIDDEN_DIGESTS[digest]}"
+        for i, line in enumerate(src.read_text(encoding="utf-8", errors="replace").split("\n"), 1)
+        for digest in _hashed_hits(line)
+    ]
+    assert not hits, (
+        "this file names, in the clear, an identifier it exists to keep out of a "
+        "public package:\n  " + "\n  ".join(hits)
+    )
+
+
+def test_no_internal_hostnames_leaked():
+    """A customer's deployment hostname identifies them as surely as their name."""
+    hits = []
+    for p in _scannable():
+        for i, line in enumerate(p.read_text(encoding="utf-8", errors="replace").split("\n"), 1):
+            for host in _URL.findall(line):
+                labels = host.lower().split(".")
+                if any(label in FORBIDDEN_OWN for label in labels) or _hashed_hits(host):
+                    hits.append(f"{p.relative_to(ROOT)}:{i}")
+    assert not hits, f"internal/customer hostnames in a public package: {hits}"