failproofai 1.0.12-beta.2 → 1.0.13-beta.1

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

@@ -0,0 +1,198 @@
+"""Commands aligned with the FailproofAI Cloud staging API after the #885 port:
+every-kind policy backtests, Jev/both authoring, issue board filters and facets,
+evaluation facets, session import and judge/Jev backfill."""
+
+import gzip
+import json
+
+import pytest
+import respx
+
+from fp_cli.app import app
+
+BASE = "http://dash.test"
+CHECKS = [{"name": "prod-db", "question": "Does this touch the production database?"}]
+
+
+def sse(events):
+    return "".join(f"data: {json.dumps(e)}\n\n" for e in events)
+
+
+def test_backtest_regex_file_keeps_the_module_route(logged_in, runner, tmp_path):
+    src = tmp_path / "p.mjs"
+    src.write_text("export default {}")
+    with respx.mock as mock:
+        route = mock.post(f"{BASE}/api/agent/policy-backtest").respond(200, json={"matched": 0})
+        result = runner.invoke(app, ["--json", "policies", "backtest", str(src), "--agent-id", "a1", "--hours", "24"])
+    assert result.exit_code == 0, result.output
+    assert json.loads(route.calls[0].request.content) == {"source": "export default {}", "agentId": "a1", "hours": 24}
+
+
+def test_backtest_published_jev_policy_uses_backtest_all_estimate(logged_in, runner):
+    with respx.mock as mock:
+        mock.get(f"{BASE}/api/enforcement/policies").respond(200, json=[
+            {"id": "p1", "version": 1, "kind": "jev", "semantic": CHECKS},
+        ])
+        route = mock.post(f"{BASE}/api/agent/policy-backtest-all").respond(200, json={"kind": "jev", "mode": "estimate"})
+        result = runner.invoke(app, ["--json", "policies", "backtest", "p1"])
+    assert result.exit_code == 0, result.output
+    assert json.loads(route.calls[0].request.content) == {
+        "kind": "jev", "semantic": CHECKS, "hours": 168, "mode": "estimate",
+    }
+
+
+def test_backtest_both_from_files_with_run(logged_in, runner, tmp_path):
+    src, sem = tmp_path / "p.mjs", tmp_path / "checks.json"
+    src.write_text("export default {}")
+    sem.write_text(json.dumps(CHECKS))
+    with respx.mock as mock:
+        route = mock.post(f"{BASE}/api/agent/policy-backtest-all").respond(200, json={"kind": "both"})
+        result = runner.invoke(app, ["--json", "policies", "backtest", str(src), "--semantic", str(sem),
+                                     "--run", "--sample", "10"])
+    assert result.exit_code == 0, result.output
+    body = json.loads(route.calls[0].request.content)
+    assert body["kind"] == "both" and body["mode"] == "run" and body["sample"] == 10
+    assert body["source"] == "export default {}" and body["semantic"] == CHECKS
+
+
+@pytest.mark.parametrize("argv", [
+    ["policies", "backtest"],
+    ["policies", "backtest", "--kind", "jev", "--semantic", "missing.json"],
+    ["policies", "backtest", "x.mjs", "--kind", "nope"],
+    ["policies", "backtest", "x.mjs", "--sample", "99"],
+])
+def test_backtest_usage_errors(logged_in, runner, argv):
+    with respx.mock(assert_all_called=False):
+        result = runner.invoke(app, ["--json", *argv])
+    assert result.exit_code == 2, result.output
+
+
+@pytest.mark.parametrize("kind,sent", [(None, None), ("regex", None), ("jev", "jev"), ("both", "both")])
+def test_author_kind(logged_in, runner, kind, sent):
+    with respx.mock as mock:
+        route = mock.post(f"{BASE}/api/agent/policy-author").respond(
+            200, text=sse([{"type": "done", "result": {"source": "x"}}]))
+        result = runner.invoke(app, ["--json", "policies", "author", "No prod DB",
+                                     *(["--kind", kind] if kind else [])])
+    assert result.exit_code == 0, result.output
+    assert json.loads(route.calls[0].request.content).get("kind") == sent
+
+
+@pytest.mark.parametrize("key_mode", [False, True])
+def test_issue_list_filters(logged_in, runner, key_mode):
+    prefix = "/v1" if key_mode else "/api"
+    with respx.mock as mock:
+        route = mock.get(f"{BASE}{prefix}/issues").respond(200, json=[])
+        result = runner.invoke(app, ["--json", *(["--api-key", "k"] if key_mode else []), "issues", "list",
+                                     "--agent-id", "a1,a2", "--source", "audit", "--assignee", "me",
+                                     "--archived", "all", "--search", "timeout"])
+    assert result.exit_code == 0, result.output
+    params = route.calls[0].request.url.params
+    assert params["agent"] == "a1,a2" and params["source"] == "audit"
+    assert params["assignee"] == "me" and params["archived"] == "all" and params["q"] == "timeout"
+    assert json.loads(result.stdout) == {"issues": []}
+
+
+def test_issue_list_alert_id_alone_keeps_the_alert_route(logged_in, runner):
+    with respx.mock as mock:
+        route = mock.get(f"{BASE}/api/alerts/al1/issues").respond(200, json=[])
+        result = runner.invoke(app, ["--json", "issues", "list", "--alert-id", "al1"])
+    assert result.exit_code == 0, result.output
+    assert route.called
+
+
+def test_issue_count_and_facets(logged_in, runner):
+    with respx.mock as mock:
+        count = mock.get(f"{BASE}/api/issues/count").respond(200, json={"count": 3})
+        facets = mock.get(f"{BASE}/api/issues/facets").respond(200, json={"agents": [{"value": "a1", "count": 3}]})
+        r1 = runner.invoke(app, ["--json", "issues", "count", "--env", "prod"])
+        r2 = runner.invoke(app, ["--json", "issues", "facets", "--state", "firing"])
+    assert r1.exit_code == 0 and json.loads(r1.stdout) == {"count": 3}
+    assert count.calls[0].request.url.params["environment"] == "prod"
+    assert r2.exit_code == 0, r2.output
+    assert facets.calls[0].request.url.params["state"] == "firing"
+
+
+def test_issue_filter_validation(logged_in, runner):
+    with respx.mock(assert_all_called=False):
+        assert runner.invoke(app, ["issues", "list", "--archived", "maybe"]).exit_code == 2
+        assert runner.invoke(app, ["issues", "list", "--source", "slack"]).exit_code == 2
+
+
+@pytest.mark.parametrize("name,path,v1,body,values", [
+    ("trigger_events", "/api/events/trigger_events", "/v1/events/trigger_events", ["PreToolUse"], ["PreToolUse"]),
+    ("eval_envs", "/api/evaluations/environments", "/v1/evaluations/environments", ["prod"], ["prod"]),
+    ("metric_keys", "/api/evaluations/metric-keys", "/v1/evaluations/metric_keys",
+     [{"name": "latency_ms", "unit": "ms", "count": 4}], ["latency_ms"]),
+])
+@pytest.mark.parametrize("key_mode", [False, True])
+def test_new_list_facets(logged_in, runner, name, path, v1, body, values, key_mode):
+    with respx.mock as mock:
+        mock.get(f"{BASE}{v1 if key_mode else path}").respond(200, json=body)
+        result = runner.invoke(app, ["--json", *(["--api-key", "k"] if key_mode else []), "list", name])
+    assert result.exit_code == 0, result.output
+    assert json.loads(result.stdout) == {"kind": name, "values": values}
+
+
+def test_sessions_import_gzips_and_shares_one_cutoff(logged_in, runner, tmp_path):
+    first, second = tmp_path / "proj" / "s1.jsonl", tmp_path / "proj" / "s2.jsonl.gz"
+    first.parent.mkdir()
+    first.write_text('{"type":"user"}\n')
+    second.write_bytes(gzip.compress(b'{"type":"user"}\n'))
+    with respx.mock as mock:
+        route = mock.post(f"{BASE}/api/events/import").respond(200, json={"sessions": 1})
+        result = runner.invoke(app, ["--json", "sessions", "import", str(first), str(second),
+                                     "--format", "claude", "--env", "dev", "--dry-run"])
+    assert result.exit_code == 0, result.output
+    assert len(route.calls) == 2
+    a, b = (c.request for c in route.calls)
+    assert gzip.decompress(a.content) == b'{"type":"user"}\n'
+    assert gzip.decompress(b.content) == b'{"type":"user"}\n'
+    assert a.headers["content-type"] == "application/octet-stream"
+    assert a.url.params["path"] == "proj/s1.jsonl" and a.url.params["format"] == "claude"
+    assert a.url.params["dry_run"] == "true" and a.url.params["environment"] == "dev"
+    assert a.url.params["existing_before"] == b.url.params["existing_before"]
+    out = json.loads(result.stdout)
+    assert [f["file"] for f in out["files"]] == [str(first), str(second)]
+
+
+def test_sessions_import_bad_format_and_missing_file(logged_in, runner, tmp_path):
+    with respx.mock(assert_all_called=False):
+        assert runner.invoke(app, ["sessions", "import", "x", "--format", "zip"]).exit_code == 2
+        assert runner.invoke(app, ["sessions", "import", str(tmp_path / "none.jsonl")]).exit_code == 2
+
+
+def test_sessions_list_still_works_as_a_group_callback(logged_in, runner):
+    with respx.mock as mock:
+        mock.get(f"{BASE}/api/sessions").respond(200, json={"sessions": [], "next_cursor": None})
+        result = runner.invoke(app, ["--json", "sessions", "--limit", "5"])
+    assert result.exit_code == 0, result.output
+
+
+def test_deploy_backfill_allows_judge(logged_in, runner):
+    with respx.mock as mock:
+        mock.get(f"{BASE}/api/evaluator-definitions").respond(200, json=[])
+        mock.post(f"{BASE}/api/evaluator-definitions").respond(201, json={"id": "d1"})
+        backfill = mock.post(f"{BASE}/api/evaluations/backfill").respond(200, json={"enqueued": 2})
+        result = runner.invoke(app, ["--json", "evaluators", "deploy", "relevance", "--judge",
+                                     "--criteria", "Grade relevance", "--threshold", "0.7", "--backfill", "7d"])
+    assert result.exit_code == 0, result.output
+    assert json.loads(backfill.calls[0].request.content)["eval_key"] == "relevance"
+    assert "model budget" in result.stderr
+
+
+def test_usage_windows_needs_a_key(logged_in, runner):
+    with respx.mock as mock:
+        result = runner.invoke(app, ["--json", "usage", "windows"])
+        assert not mock.calls
+    assert result.exit_code == 2
+
+
+def test_sessions_import_public_format_name_maps_to_the_wire_name(logged_in, runner, tmp_path):
+    f = tmp_path / "events.jsonl"
+    f.write_text('{"event_type":"agent_start"}\n')
+    with respx.mock as mock:
+        route = mock.post(f"{BASE}/api/events/import").respond(200, json={})
+        result = runner.invoke(app, ["--json", "sessions", "import", str(f), "--format", "failproofai"])
+    assert result.exit_code == 0, result.output
+    assert route.calls[0].request.url.params["format"] == "agenteye"

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

@@ -66,7 +66,7 @@ def test_whoami_human_renders_header_and_panels(logged_in, runner):
     assert "62230791-4811-4f04-b388-ae57bdcb422e" in out
     assert "instance admin" in out
     # permissions panel
-    assert "permissions" in out
+    assert "PERMISSIONS" in out
     assert "dashboards" in out and "read" in out and "write" in out and "delete" in out
     # orgs panel + switch hint to the non-active org
     assert "your orgs" in out

package/.next/standalone/fp-cloud-cli/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [[package]]
@@ -372,7 +372,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.71.0"
+version = "7.75.11"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "backoff" },
@@ -380,9 +380,9 @@ dependencies = [
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c6/9b/12e2e82fbbf5d70f554cfd1930631a6d1cce8975721ad50b5d7b47e580ff/posthog-7.71.0.tar.gz", hash = "sha256:00950999edf7f613a90015126bacc431d3ab3964a70d91c2f792e6a0dc81f358", size = 763019, upload-time = "2026-10-16T19:24:33.765Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/ee/6c0ad2557d82a626dbd14453fada5b93c4c78a9e696f4e74b5672facd29a/posthog-7.75.11.tar.gz", hash = "sha256:c55e8de3943cc9cd86a8eda893f5ea1b9d631f52a2758dd14c0c17ef52632908", size = 819642, upload-time = "2026-10-23T15:26:56.068Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f5/8e/9b185e665800a922e95fb965fb9c17d2a54cee575cf5e425308250663393/posthog-7.71.0-py3-none-any.whl", hash = "sha256:52cb1320b7e178b36ef7594cf15b4a8c492c24d4d1c46700f5bee0089ba5c6ac", size = 892234, upload-time = "2026-10-16T19:24:31.706Z" },
+    { url = "https://files.pythonhosted.org/packages/50/8c/7765ea5122fe96daf9d3db4653fc37f2ca5115e2f6f7f4d74f0867433a8a/posthog-7.75.11-py3-none-any.whl", hash = "sha256:c65d173b24ec82cbf0f977f4779348512a7f71b761809786e87ae47e347ebab1", size = 958056, upload-time = "2026-10-23T15:26:54.116Z" },
 ]
 
 [[package]]

package/.next/standalone/hermes-plugin/plugin.yaml

@@ -1,5 +1,5 @@
 name: failproofai
-version: 1.0.12-beta.2
+version: 1.0.13-beta.1
 description: Real-time FailproofAI policy enforcement for Hermes
 manifest_version: 2
 api_version: 1

package/.next/standalone/node_modules/@next/env/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/env",
-  "version": "16.4.2",
+  "version": "16.4.3",
   "keywords": [
     "react",
     "next",

package/.next/standalone/node_modules/next/dist/build/swc/index.js

@@ -130,7 +130,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const nextVersion = "16.4.2";
+const nextVersion = "16.4.3";
 const ArchName = (0, _os.arch)();
 const PlatformName = (0, _os.platform)();
 function infoLog(...args) {