failproofai 1.0.1 → 1.0.2-beta.0

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

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import os
+import stat
+from datetime import datetime, timedelta, timezone
+
+from fp_cli import config
+
+
+def _iso(delta: timedelta) -> str:
+    return (datetime.now(timezone.utc) + delta).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def test_load_missing_returns_defaults(home):
+    cfg = config.load_config()
+    assert cfg.base_url is None  # no default URL — it must be set explicitly
+    assert cfg.session_token is None
+
+
+def test_save_and_load_roundtrip(home):
+    cfg = config.CliConfig(
+        base_url="http://x.test",
+        session_token="t",
+        expires_at="2999-01-01T00:00:00Z",
+        email="e@test",
+        user_id="u",
+    )
+    config.save_config(cfg)
+    assert config.load_config() == cfg
+
+
+def test_save_uses_0600_permissions(home):
+    config.save_config(config.CliConfig())
+    mode = stat.S_IMODE(os.stat(config.config_path()).st_mode)
+    assert mode == 0o600
+
+
+def test_base_dir_respects_fp_home(home):
+    assert config.base_dir() == home
+
+
+def test_clear_token_wipes_session_identity_and_org(home):
+    # logout must leave NO stale identity: token, expiry, email, user id, and the
+    # active org are all cleared. base_url / insecure / anonymous_id are kept so the
+    # next login doesn't need them re-specified and telemetry stays stable.
+    config.save_config(
+        config.CliConfig(
+            base_url="http://x.test",
+            session_token="t",
+            expires_at="2999-01-01T00:00:00Z",
+            email="e@test",
+            user_id="u1",
+            insecure=True,
+            org="acme",
+            anonymous_id="anon-123",
+        )
+    )
+    config.clear_token(config.load_config())
+    reloaded = config.load_config()
+    # cleared — nothing about who/where remains
+    assert reloaded.session_token is None
+    assert reloaded.expires_at is None
+    assert reloaded.email is None
+    assert reloaded.user_id is None
+    assert reloaded.org is None
+    # kept — preferences + stable machine id
+    assert reloaded.base_url == "http://x.test"
+    assert reloaded.insecure is True
+    assert reloaded.anonymous_id == "anon-123"
+
+
+def test_corrupt_file_falls_back_to_defaults(home):
+    path = config.config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("{ not json")
+    assert config.load_config().base_url is None
+
+
+def test_is_expired():
+    assert config.is_expired(config.CliConfig()) is True  # no token at all
+    assert config.is_expired(config.CliConfig(session_token="t")) is True  # no expiry
+    assert config.is_expired(
+        config.CliConfig(session_token="t", expires_at=_iso(timedelta(hours=-1)))
+    ) is True
+    assert config.is_expired(
+        config.CliConfig(session_token="t", expires_at=_iso(timedelta(hours=1)))
+    ) is False
+
+
+def test_is_expired_handles_z_suffix_and_skew():
+    # 30s in the future is "expired" under the default 60s skew.
+    soon = _iso(timedelta(seconds=30))
+    assert config.is_expired(config.CliConfig(session_token="t", expires_at=soon)) is True
+
+
+def test_insecure_defaults_false_and_roundtrips(home):
+    assert config.load_config().insecure is False  # secure by default
+    config.save_config(config.CliConfig(insecure=True))
+    assert config.load_config().insecure is True

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

@@ -0,0 +1,340 @@
+"""The agent assistant (SSE)."""
+
+from __future__ import annotations
+
+import json
+
+import httpx
+import respx
+
+from fp_cli.app import app
+
+BASE = "http://dash.test"
+
+
+def _sse(events) -> httpx.Response:
+    body = "".join(f"data: {json.dumps(e)}\n\n" for e in events)
+    return httpx.Response(200, text=body, headers={"content-type": "text/event-stream"})
+
+
+# --- agent ------------------------------------------------------------------
+
+
+@respx.mock
+def test_agent_health(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/health").mock(
+        return_value=httpx.Response(200, json={"enabled": True, "llm_configured": True, "default_model": "claude-x"})
+    )
+    result = runner.invoke(app, ["--json", "agent", "health"])
+    assert result.exit_code == 0, result.output
+    assert json.loads(result.stdout)["enabled"] is True
+
+
+@respx.mock
+def test_agent_models_lists_allowlist(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/health").mock(
+        return_value=httpx.Response(200, json={"enabled": True, "models": ["m-default", "m-fast"], "defaultModel": "m-default"})
+    )
+    result = runner.invoke(app, ["--json", "agent", "models"])
+    assert result.exit_code == 0, result.output
+    data = json.loads(result.stdout)
+    assert data["models"] == ["m-default", "m-fast"]
+    assert data["default_model"] == "m-default"
+
+
+@respx.mock
+def test_agent_chats_list(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/conversations").mock(
+        return_value=httpx.Response(200, json={"conversations": [{"id": "c1", "title": "hi", "message_count": 2, "updated_at": "t"}]})
+    )
+    result = runner.invoke(app, ["--json", "agent", "chats"])
+    assert result.exit_code == 0, result.output
+    assert json.loads(result.stdout)["chats"][0]["id"] == "c1"
+
+
+@respx.mock
+def test_agent_ask_new_chat_creates_persists_and_returns_id(logged_in, runner):
+    respx.post(f"{BASE}/api/agent/chat").mock(
+        return_value=_sse([
+            {"type": "text-delta", "text": "Hello "},
+            {"type": "tool-start", "tool": "run_query", "toolCallId": "1"},
+            {"type": "text-delta", "text": "world"},
+            {"type": "done"},
+        ])
+    )
+    create = respx.post(f"{BASE}/api/agent/conversations").mock(
+        return_value=httpx.Response(200, json={"id": "c9", "title": "New conversation"})
+    )
+    put = respx.put(f"{BASE}/api/agent/conversations/c9/messages").mock(return_value=httpx.Response(200, json={}))
+    patch = respx.patch(f"{BASE}/api/agent/conversations/c9").mock(return_value=httpx.Response(200, json={}))
+    result = runner.invoke(app, ["--json", "agent", "ask", "hi there"])  # message is positional now
+    assert result.exit_code == 0, result.output
+    data = json.loads(result.stdout)
+    assert data["answer"] == "Hello world"
+    assert data["tools"] == ["run_query"]
+    assert data["chat_id"] == "c9"  # the new chat id is surfaced
+    assert create.called            # no --chat ⇒ a new chat was created
+    # persisted [user, assistant] in the shared {role, content:{text}} shape
+    assert json.loads(put.calls.last.request.content)["messages"] == [
+        {"role": "user", "content": {"text": "hi there"}},
+        {"role": "assistant", "content": {"text": "Hello world"}},
+    ]
+    assert json.loads(create.calls.last.request.content)["title"] == "hi there"  # titled at creation
+
+
+@respx.mock
+def test_agent_ask_interactive_aborts_without_creating_chat(logged_in, runner):
+    # No conversation routes are mocked — if a chat were created, respx would error.
+    respx.post(f"{BASE}/api/agent/chat").mock(
+        return_value=_sse([
+            {"type": "text-delta", "text": "let me check"},
+            {"type": "ask-user", "callId": "x", "kind": "approval", "question": "ok to run?", "allowText": True},
+        ])
+    )
+    result = runner.invoke(app, ["agent", "ask", "do it"])
+    assert result.exit_code == 1  # clean abort, no orphan chat
+
+
+@respx.mock
+def test_agent_ask_not_configured_503(logged_in, runner):
+    respx.post(f"{BASE}/api/agent/chat").mock(return_value=httpx.Response(503, json={"error": "assistant not configured"}))
+    result = runner.invoke(app, ["agent", "ask", "hi"])
+    assert result.exit_code == 1  # ApiError surfaced; no chat created
+
+
+@respx.mock
+def test_agent_ask_chat_continues_existing_thread(logged_in, runner):
+    # --chat resolves via the chat list first, then loads the thread by full id.
+    respx.get(f"{BASE}/api/agent/conversations").mock(
+        return_value=httpx.Response(200, json={"conversations": [{"id": "c1", "title": "perf review", "message_count": 2}]})
+    )
+    respx.get(f"{BASE}/api/agent/conversations/c1").mock(
+        return_value=httpx.Response(200, json={"title": "perf review", "messages": [
+            {"role": "user", "content": {"text": "earlier q"}},
+            {"role": "assistant", "content": {"text": "earlier a"}},
+        ]})
+    )
+    chat = respx.post(f"{BASE}/api/agent/chat").mock(
+        return_value=_sse([{"type": "text-delta", "text": "follow up"}, {"type": "done"}])
+    )
+    put = respx.put(f"{BASE}/api/agent/conversations/c1/messages").mock(return_value=httpx.Response(200, json={}))
+    patch = respx.patch(f"{BASE}/api/agent/conversations/c1").mock(return_value=httpx.Response(200, json={}))
+    create = respx.post(f"{BASE}/api/agent/conversations").mock(return_value=httpx.Response(200, json={"id": "cNEW"}))
+    result = runner.invoke(app, ["--json", "agent", "ask", "and now?", "--chat", "c1"])
+    assert result.exit_code == 0, result.output
+    # prior thread + new user turn sent to the agent for context
+    sent = json.loads(chat.calls.last.request.content)["messages"]
+    assert len(sent) == 3 and sent[-1] == {"role": "user", "content": {"text": "and now?"}}
+    # persisted = history + user + assistant; existing title NOT overwritten; no new chat made
+    saved = json.loads(put.calls.last.request.content)["messages"]
+    assert len(saved) == 4 and saved[-1] == {"role": "assistant", "content": {"text": "follow up"}}
+    assert not patch.called
+    assert not create.called
+    assert json.loads(result.stdout)["chat_id"] == "c1"
+
+
+@respx.mock
+def test_agent_ask_rejects_unknown_model(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/health").mock(
+        return_value=httpx.Response(200, json={"enabled": True, "models": ["m-default", "m-fast"], "defaultModel": "m-default"})
+    )
+    chat = respx.post(f"{BASE}/api/agent/chat").mock(return_value=_sse([{"type": "done"}]))
+    result = runner.invoke(app, ["agent", "ask", "hi", "--model", "bogus-model"])
+    assert result.exit_code == 2  # BadParameter — validated against the allowlist before chatting
+    assert not chat.called
+
+
+@respx.mock
+def test_agent_ask_accepts_allowlisted_model_and_forwards_it(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/health").mock(
+        return_value=httpx.Response(200, json={"enabled": True, "models": ["m-default", "m-fast"], "defaultModel": "m-default"})
+    )
+    respx.post(f"{BASE}/api/agent/chat").mock(return_value=_sse([{"type": "text-delta", "text": "ok"}, {"type": "done"}]))
+    respx.post(f"{BASE}/api/agent/conversations").mock(return_value=httpx.Response(200, json={"id": "c9"}))
+    respx.put(f"{BASE}/api/agent/conversations/c9/messages").mock(return_value=httpx.Response(200, json={}))
+    respx.patch(f"{BASE}/api/agent/conversations/c9").mock(return_value=httpx.Response(200, json={}))
+    result = runner.invoke(app, ["--json", "agent", "ask", "hi", "--model", "m-fast"])
+    assert result.exit_code == 0, result.output
+    chat_calls = [c for c in respx.calls if c.request.url.path == "/api/agent/chat"]
+    assert json.loads(chat_calls[-1].request.content)["model"] == "m-fast"  # chosen model forwarded
+
+
+# --- agent: redesigned UI (render assertions; the JSON contracts above are unchanged) ---
+
+
+@respx.mock
+def test_agent_health_renders_configured_card(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/health").mock(
+        return_value=httpx.Response(200, json={"enabled": True, "llm_configured": True,
+                                               "default_model": "claude-x", "models": ["claude-x", "claude-fast"]})
+    )
+    result = runner.invoke(app, ["agent", "health"])
+    assert result.exit_code == 0, result.output
+    out = result.stdout
+    assert "assistant" in out and "configured" in out and "claude-x" in out
+
+
+@respx.mock
+def test_agent_health_renders_not_configured(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/health").mock(
+        return_value=httpx.Response(200, json={"enabled": False, "llm_configured": False})
+    )
+    result = runner.invoke(app, ["agent", "health"])
+    assert result.exit_code == 0, result.output
+    assert "not configured" in result.stdout
+
+
+@respx.mock
+def test_agent_models_renders_default_marker(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/health").mock(
+        return_value=httpx.Response(200, json={"enabled": True, "models": ["m-default", "m-fast"], "defaultModel": "m-default"})
+    )
+    result = runner.invoke(app, ["agent", "models"])
+    assert result.exit_code == 0, result.output
+    out = result.stdout
+    assert "models" in out and "m-default" in out and "m-fast" in out and "default" in out
+
+
+@respx.mock
+def test_agent_models_empty_is_calm_and_notes_unconfigured(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/health").mock(return_value=httpx.Response(200, json={"enabled": False}))
+    result = runner.invoke(app, ["agent", "models"])
+    assert result.exit_code == 0, result.output
+    assert "no models reported" in result.stdout
+    assert "isn't configured" in (result.stderr or "")
+
+
+@respx.mock
+def test_agent_chats_renders_table(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/conversations").mock(
+        return_value=httpx.Response(200, json={"conversations": [
+            {"id": "c1", "title": "perf review", "message_count": 4, "updated_at": "2026-06-27T10:00:00Z"},
+        ]})
+    )
+    result = runner.invoke(app, ["agent", "chats"])
+    assert result.exit_code == 0, result.output
+    assert "chats" in result.stdout and "perf review" in result.stdout
+    assert "chat-id" in result.stdout and "c1" in result.stdout  # full chat-id column by default
+    assert "open one with" not in (result.stderr or "")           # footer removed
+
+
+@respx.mock
+def test_agent_chats_empty_is_calm(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/conversations").mock(return_value=httpx.Response(200, json={"conversations": []}))
+    result = runner.invoke(app, ["agent", "chats"])
+    assert result.exit_code == 0, result.output
+    assert "no chats" in result.stdout
+
+
+@respx.mock
+def test_agent_show_renders_thread(logged_in, runner):
+    # show resolves the (short) id via the chat list, then loads the thread by full id.
+    respx.get(f"{BASE}/api/agent/conversations").mock(
+        return_value=httpx.Response(200, json={"conversations": [{"id": "c1", "title": "perf review", "message_count": 2}]})
+    )
+    respx.get(f"{BASE}/api/agent/conversations/c1").mock(
+        return_value=httpx.Response(200, json={"title": "perf review", "messages": [
+            {"role": "user", "content": {"text": "why slow"}},
+            {"role": "assistant", "content": "because cache"},  # str-or-{text}: both extracted
+        ]})
+    )
+    result = runner.invoke(app, ["agent", "show", "c1"])
+    assert result.exit_code == 0, result.output
+    out = result.stdout
+    assert "perf review" in out and "you" in out and "assistant" in out
+    assert "why slow" in out and "because cache" in out
+
+
+@respx.mock
+def test_agent_show_not_found_exits_6(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/conversations").mock(return_value=httpx.Response(200, json={"conversations": []}))
+    result = runner.invoke(app, ["agent", "show", "ghost"])
+    assert result.exit_code == 6
+    assert "chat not found" in (result.stderr or result.output)
+
+
+@respx.mock
+def test_agent_show_not_found_json(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/conversations").mock(return_value=httpx.Response(200, json={"conversations": []}))
+    result = runner.invoke(app, ["--json", "agent", "show", "ghost"])
+    assert result.exit_code == 6
+    assert "chat not found" in json.loads(result.stdout)["error"]
+
+
+@respx.mock
+def test_agent_rename_renders_card_and_keeps_json(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/conversations").mock(
+        return_value=httpx.Response(200, json={"conversations": [{"id": "c1", "title": "old name", "message_count": 0}]})
+    )
+    patch = respx.patch(f"{BASE}/api/agent/conversations/c1").mock(return_value=httpx.Response(200, json={}))
+    result = runner.invoke(app, ["agent", "rename", "c1", "--title", "new name"])
+    assert result.exit_code == 0, result.output
+    err = result.stderr or ""
+    assert "chat renamed" in err and "new name" in err and "was old name" in err
+    assert json.loads(patch.calls.last.request.content)["title"] == "new name"
+    # JSON contract unchanged (now the full resolved id)
+    result2 = runner.invoke(app, ["--json", "agent", "rename", "c1", "--title", "x"])
+    assert json.loads(result2.stdout) == {"id": "c1", "title": "x"}
+
+
+@respx.mock
+def test_agent_rename_not_found_exits_6(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/conversations").mock(return_value=httpx.Response(200, json={"conversations": []}))
+    result = runner.invoke(app, ["agent", "rename", "ghost", "--title", "x"])
+    assert result.exit_code == 6
+    assert "chat not found" in (result.stderr or result.output)
+
+
+@respx.mock
+def test_agent_delete_yes_renders_and_keeps_json(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/conversations").mock(
+        return_value=httpx.Response(200, json={"conversations": [{"id": "c1", "title": "perf review", "message_count": 1}]})
+    )
+    delete = respx.delete(f"{BASE}/api/agent/conversations/c1").mock(return_value=httpx.Response(200, json={}))
+    result = runner.invoke(app, ["agent", "delete", "c1", "--yes"])
+    assert result.exit_code == 0, result.output
+    err = result.stderr or ""
+    assert "deleted chat" in err and "perf review" in err
+    assert delete.called
+    # JSON contract (now also carries the title)
+    result2 = runner.invoke(app, ["--json", "agent", "delete", "c1", "--yes"])
+    body = json.loads(result2.stdout)
+    assert body["deleted"] is True and body["id"] == "c1" and body["title"] == "perf review"
+
+
+@respx.mock
+def test_agent_delete_not_found_exits_6(logged_in, runner):
+    respx.get(f"{BASE}/api/agent/conversations").mock(return_value=httpx.Response(200, json={"conversations": []}))
+    result = runner.invoke(app, ["agent", "delete", "ghost", "--yes"])
+    assert result.exit_code == 6
+    assert "chat not found" in (result.stderr or result.output)
+
+
+@respx.mock
+def test_agent_ask_answer_to_stdout_chrome_to_stderr(logged_in, runner):
+    respx.post(f"{BASE}/api/agent/chat").mock(
+        return_value=_sse([
+            {"type": "tool-start", "tool": "run_query"},
+            {"type": "text-delta", "text": "the answer"},
+            {"type": "done"},
+        ])
+    )
+    respx.post(f"{BASE}/api/agent/conversations").mock(return_value=httpx.Response(200, json={"id": "c9"}))
+    respx.put(f"{BASE}/api/agent/conversations/c9/messages").mock(return_value=httpx.Response(200, json={}))
+    respx.patch(f"{BASE}/api/agent/conversations/c9").mock(return_value=httpx.Response(200, json={}))
+    result = runner.invoke(app, ["agent", "ask", "q"])
+    assert result.exit_code == 0, result.output
+    assert result.stdout.strip() == "the answer"  # piped (non-tty) → ONLY the raw answer on stdout
+    err = result.stderr or ""
+    assert "used tool: run_query" in err
+    assert "new chat" in err and "fp agent ask --chat c9" in err
+
+
+@respx.mock
+def test_agent_ask_assistant_error_clean_exit_1(logged_in, runner):
+    respx.post(f"{BASE}/api/agent/chat").mock(
+        return_value=_sse([{"type": "error", "message": "model overloaded"}])
+    )
+    result = runner.invoke(app, ["agent", "ask", "q"])
+    assert result.exit_code == 1
+    assert "✗" in (result.stderr or "") and "model overloaded" in (result.stderr or "")

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

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import pytest
+
+from fp_cli import dates
+
+NOW = datetime(2026, 5, 25, 12, 0, 0, tzinfo=timezone.utc)
+
+
+def test_all_and_none_have_no_bounds():
+    assert dates.resolve_range("all") == (None, None)
+    assert dates.resolve_range(None) == (None, None)
+
+
+@pytest.mark.parametrize(
+    "preset,expected_from",
+    [
+        ("15m", "2026-05-25T11:45:00Z"),
+        ("1h", "2026-05-25T11:00:00Z"),
+        ("6h", "2026-05-25T06:00:00Z"),
+        ("24h", "2026-05-24T12:00:00Z"),
+        ("7d", "2026-05-18T12:00:00Z"),
+    ],
+)
+def test_presets(preset, expected_from):
+    ts_from, ts_to = dates.resolve_range(preset, now=NOW)
+    assert ts_from == expected_from
+    assert ts_to is None
+
+
+def test_custom_from_to_overrides_since():
+    ts_from, ts_to = dates.resolve_range(
+        "24h", "2020-01-01T00:00:00Z", "2020-01-02T00:00:00Z", now=NOW
+    )
+    assert ts_from == "2020-01-01T00:00:00Z"
+    assert ts_to == "2020-01-02T00:00:00Z"
+
+
+def test_invalid_since_raises():
+    with pytest.raises(ValueError):
+        dates.resolve_range("bogus", now=NOW)
+
+
+@pytest.mark.parametrize(
+    "ok_value",
+    ["2026-05-01T00:00:00Z", "2026-05-01T00:00:00+00:00", "2026-05-01T12:30:00-05:00"],
+)
+def test_from_accepts_rfc3339_with_timezone(ok_value):
+    ts_from, _ = dates.resolve_range(None, ok_value, None, now=NOW)
+    assert ts_from == ok_value
+
+
+@pytest.mark.parametrize(
+    "bad_value",
+    [
+        "2026-05-01",              # date only
+        "2026-05-01T00:00:00",     # no timezone offset → server 400
+        "2026-05-01 00:00:00Z",    # space separator, not 'T'
+        "not-a-date",
+    ],
+)
+def test_from_rejects_naive_or_malformed(bad_value):
+    # These deserialize to a server 400 (exit 1); validating client-side keeps them a
+    # clean usage error (exit 2). Applies to --from and --to alike.
+    with pytest.raises(ValueError):
+        dates.resolve_range(None, bad_value, None, now=NOW)
+    with pytest.raises(ValueError):
+        dates.resolve_range(None, None, bad_value, now=NOW)
+
+
+def test_since_choices_cover_presets():
+    for preset in dates.PRESETS:
+        assert preset in dates.SINCE_CHOICES
+    assert "all" in dates.SINCE_CHOICES