flowent 0.0.6 → 0.0.10

package/backend/tests/unit/test_access.py

@@ -1,45 +0,0 @@
-from loguru import logger
-
-from flowent.access import (
-    ensure_access_bootstrap,
-    is_access_configured,
-    set_access_code,
-)
-from flowent.settings import Settings
-
-
-def test_ensure_access_bootstrap_generates_and_logs_access_code() -> None:
-    settings = Settings()
-    messages: list[str] = []
-    sink_id = logger.add(messages.append, format="{message}")
-
-    try:
-        generated_code = ensure_access_bootstrap(settings)
-    finally:
-        logger.remove(sink_id)
-
-    assert generated_code
-    assert settings.access.code == generated_code
-    assert is_access_configured(settings.access)
-    assert any(
-        f"Flowent admin access code: {generated_code}" in message
-        for message in messages
-    )
-
-
-def test_ensure_access_bootstrap_logs_existing_persisted_access_code() -> None:
-    settings = Settings()
-    set_access_code(settings, "TEST-ACCESS-CODE")
-    messages: list[str] = []
-    sink_id = logger.add(messages.append, format="{message}")
-
-    try:
-        generated_code = ensure_access_bootstrap(settings)
-    finally:
-        logger.remove(sink_id)
-
-    assert generated_code is None
-    assert settings.access.code == "TEST-ACCESS-CODE"
-    assert any(
-        "Flowent admin access code: TEST-ACCESS-CODE" in message for message in messages
-    )

package/backend/tests/unit/test_cli.py

@@ -1,124 +0,0 @@
-import os
-
-import pytest
-
-from flowent.access import is_access_configured, set_access_code, verify_access_code
-from flowent.cli import APP_DATA_DIR_ENV_VAR, main
-
-
-def test_access_refresh_command_generates_new_persisted_access_code(
-    monkeypatch, tmp_path, capsys
-):
-    import flowent.settings as settings_module
-
-    settings_file = tmp_path / "settings.json"
-    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
-    monkeypatch.setattr(settings_module, "_cached_settings", None)
-
-    settings = settings_module.Settings()
-    set_access_code(settings, "OLD-ACCESS-CODE")
-    settings_module.save_settings(settings)
-    monkeypatch.setattr(settings_module, "_cached_settings", None)
-
-    main(["access", "refresh"])
-
-    output = capsys.readouterr().out.strip()
-    reloaded_settings = settings_module.load_settings()
-
-    assert output.startswith("Generated new access code: ")
-    next_code = output.removeprefix("Generated new access code: ").strip()
-    assert next_code
-    assert reloaded_settings.access.code == next_code
-    assert verify_access_code(reloaded_settings.access, next_code)
-    assert not verify_access_code(reloaded_settings.access, "OLD-ACCESS-CODE")
-
-
-def test_access_reset_command_clears_persisted_access_code(
-    monkeypatch, tmp_path, capsys
-):
-    import flowent.settings as settings_module
-
-    settings_file = tmp_path / "settings.json"
-    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
-    monkeypatch.setattr(settings_module, "_cached_settings", None)
-
-    settings = settings_module.Settings()
-    set_access_code(settings, "TEST-ACCESS-CODE")
-    settings_module.save_settings(settings)
-    monkeypatch.setattr(settings_module, "_cached_settings", None)
-
-    main(["access", "reset"])
-
-    output = capsys.readouterr().out.strip()
-    reloaded_settings = settings_module.load_settings()
-
-    assert output == (
-        "Access configuration cleared. Restart Flowent to generate a new access code."
-    )
-    assert reloaded_settings.access.code == ""
-    assert not is_access_configured(reloaded_settings.access)
-
-
-def test_help_output_no_longer_lists_mcp_command(capsys):
-    with pytest.raises(SystemExit) as exc:
-        main(["--help"])
-
-    assert exc.value.code == 0
-    output = capsys.readouterr().out
-
-    assert "access" in output
-    assert "mcp" not in output
-
-
-def test_version_short_option_matches_version_output(capsys):
-    with pytest.raises(SystemExit) as exc:
-        main(["-v"])
-
-    assert exc.value.code == 0
-    assert capsys.readouterr().out.startswith("flowent ")
-
-
-def test_server_options_accept_npm_wrapper_aliases(monkeypatch):
-    called: dict[str, object] = {}
-
-    monkeypatch.setattr(
-        "uvicorn.run",
-        lambda app, *, host, port: called.update(
-            {"app": app, "host": host, "port": port}
-        ),
-    )
-
-    main(["--hostname", "127.0.0.1", "-p", "7000"])
-
-    assert called == {
-        "app": "flowent.main:app",
-        "host": "127.0.0.1",
-        "port": 7000,
-    }
-
-
-def test_removed_mcp_command_is_rejected(capsys):
-    with pytest.raises(SystemExit) as exc:
-        main(["mcp", "serve"])
-
-    assert exc.value.code == 2
-    error_output = capsys.readouterr().err
-
-    assert "invalid choice" in error_output
-    assert "'mcp'" in error_output
-
-
-def test_cli_sets_app_data_dir_env_before_dispatch(monkeypatch, tmp_path, capsys):
-    monkeypatch.delenv(APP_DATA_DIR_ENV_VAR, raising=False)
-    called: list[str] = []
-
-    monkeypatch.setattr(
-        "flowent.access.refresh_local_access",
-        lambda: called.append("refresh") or "Generated new access code: TEST",
-    )
-
-    main(["--app-data-dir", str(tmp_path), "access", "refresh"])
-
-    assert called == ["refresh"]
-    assert os.environ[APP_DATA_DIR_ENV_VAR] == str(tmp_path)
-    assert capsys.readouterr().out.strip() == "Generated new access code: TEST"

package/backend/tests/unit/test_graph_runtime.py

@@ -1,72 +0,0 @@
-from flowent.agent import Agent
-from flowent.graph_runtime import resolve_node_ref
-from flowent.models import NodeConfig, NodeType
-from flowent.registry import registry
-
-
-def setup_function():
-    registry.reset()
-
-
-def teardown_function():
-    registry.reset()
-
-
-def test_resolve_node_ref_matches_exact_uuid():
-    planner = Agent(
-        NodeConfig(node_type=NodeType.AGENT),
-        uuid="12345678-aaaa-bbbb-cccc-ddddeeeeffff",
-    )
-    registry.register(planner)
-
-    assert resolve_node_ref("12345678-aaaa-bbbb-cccc-ddddeeeeffff") is planner
-
-
-def test_resolve_node_ref_matches_exact_name():
-    planner = Agent(
-        NodeConfig(node_type=NodeType.AGENT, name="Planner"),
-        uuid="12345678-aaaa-bbbb-cccc-ddddeeeeffff",
-    )
-    registry.register(planner)
-
-    assert resolve_node_ref("Planner") is planner
-
-
-def test_resolve_node_ref_matches_short_uuid_prefix():
-    planner = Agent(
-        NodeConfig(node_type=NodeType.AGENT),
-        uuid="12345678-aaaa-bbbb-cccc-ddddeeeeffff",
-    )
-    reviewer = Agent(
-        NodeConfig(node_type=NodeType.AGENT),
-        uuid="87654321-aaaa-bbbb-cccc-ddddeeeeffff",
-    )
-    registry.register(planner)
-    registry.register(reviewer)
-
-    assert resolve_node_ref("12345678") is planner
-
-
-def test_resolve_node_ref_rejects_ambiguous_prefix():
-    planner = Agent(
-        NodeConfig(node_type=NodeType.AGENT),
-        uuid="1234aaaa-aaaa-bbbb-cccc-ddddeeeeffff",
-    )
-    reviewer = Agent(
-        NodeConfig(node_type=NodeType.AGENT),
-        uuid="1234bbbb-aaaa-bbbb-cccc-ddddeeeeffff",
-    )
-    registry.register(planner)
-    registry.register(reviewer)
-
-    assert resolve_node_ref("1234") is None
-
-
-def test_resolve_node_ref_rejects_too_short_prefix():
-    planner = Agent(
-        NodeConfig(node_type=NodeType.AGENT),
-        uuid="12345678-aaaa-bbbb-cccc-ddddeeeeffff",
-    )
-    registry.register(planner)
-
-    assert resolve_node_ref("123") is None

package/backend/tests/unit/test_network.py

@@ -1,51 +0,0 @@
-import socket
-import threading
-import time
-
-from flowent.network import create_http_session
-
-
-def _capture_raw_request() -> str:
-    captured: dict[str, str] = {}
-    ready = threading.Event()
-
-    def serve() -> None:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
-            server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            server.bind(("127.0.0.1", 18084))
-            server.listen(1)
-            ready.set()
-            connection, _ = server.accept()
-            with connection:
-                payload = b""
-                connection.settimeout(2)
-                while b"\r\n\r\n" not in payload:
-                    chunk = connection.recv(4096)
-                    if not chunk:
-                        break
-                    payload += chunk
-                captured["request"] = payload.decode("latin1", errors="replace")
-                body = b"{}"
-                connection.sendall(
-                    b"HTTP/1.1 200 OK\r\n"
-                    b"Content-Type: application/json\r\n"
-                    b"Content-Length: 2\r\n"
-                    b"Connection: close\r\n\r\n" + body
-                )
-
-    server_thread = threading.Thread(target=serve, daemon=True)
-    server_thread.start()
-    ready.wait()
-    time.sleep(0.05)
-
-    with create_http_session(timeout=5) as client:
-        response = client.post("http://127.0.0.1:18084/v1/messages", json={"x": 1})
-    assert response.status_code == 200
-    return captured["request"]
-
-
-def test_create_http_session_does_not_send_upgrade_by_default():
-    request = _capture_raw_request()
-
-    assert "Upgrade: h2c" not in request
-    assert "Connection: Upgrade" not in request

package/backend/tests/unit/test_state_sqlite_storage.py

@@ -1,159 +0,0 @@
-import base64
-import sqlite3
-import time
-
-import flowent.settings as settings_module
-from flowent.agent import Agent
-from flowent.image_assets import create_image_asset
-from flowent.mcp_service import MCPDiscoverySnapshot, MCPToolDescriptor, mcp_service
-from flowent.models import NodeConfig, NodeType
-from flowent.settings import MCPServerConfig, Settings
-
-_ONE_PIXEL_PNG = base64.b64decode(
-    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aF9sAAAAASUVORK5CYII="
-)
-
-
-def test_create_image_asset_persists_metadata_in_state_sqlite(monkeypatch, tmp_path):
-    settings_file = tmp_path / "settings.json"
-    settings_file.write_text("{}", encoding="utf-8")
-    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
-    monkeypatch.setattr(settings_module, "_cached_settings", None)
-
-    asset = create_image_asset(
-        _ONE_PIXEL_PNG,
-        mime_type="image/png",
-        original_name="pixel.png",
-    )
-
-    assert asset.file_path == tmp_path / "assets" / "images" / asset.stored_name
-    assert asset.file_path.is_file()
-    connection = sqlite3.connect(tmp_path / "state.sqlite")
-    connection.row_factory = sqlite3.Row
-    try:
-        row = connection.execute(
-            """
-            SELECT stored_name, mime_type, width, height, original_name
-            FROM image_assets
-            WHERE id = ?
-            """,
-            (asset.id,),
-        ).fetchone()
-    finally:
-        connection.close()
-    assert row is not None
-    assert row["stored_name"] == asset.stored_name
-    assert row["mime_type"] == "image/png"
-    assert row["width"] == 1
-    assert row["height"] == 1
-    assert row["original_name"] == "pixel.png"
-
-
-def test_mcp_service_restores_persisted_snapshot_and_activity_after_runtime_clear(
-    monkeypatch,
-    tmp_path,
-):
-    settings_file = tmp_path / "settings.json"
-    settings_file.write_text("{}", encoding="utf-8")
-    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
-    monkeypatch.setattr(settings_module, "_cached_settings", None)
-    mcp_service.reset()
-    now = time.time()
-
-    try:
-        mcp_service._set_snapshot(
-            MCPDiscoverySnapshot(
-                server_name="filesystem",
-                transport="stdio",
-                status="connected",
-                auth_status="unsupported",
-                last_refresh_result="success",
-            )
-        )
-        mcp_service._record_activity(
-            server_name="filesystem",
-            action="refresh",
-            actor_node_id=None,
-            tab_id=None,
-            started_at=now - 2.0,
-            ended_at=now,
-            result="success",
-            summary="Capabilities refreshed",
-        )
-
-        mcp_service.clear_runtime_state()
-
-        restored_snapshot = mcp_service._get_snapshot("filesystem")
-        restored_activities = mcp_service.list_activities(server_name="filesystem")
-
-        assert restored_snapshot is not None
-        assert restored_snapshot.status == "connected"
-        assert restored_snapshot.last_refresh_result == "success"
-        assert len(restored_activities) == 1
-        assert restored_activities[0].server_name == "filesystem"
-        assert restored_activities[0].summary == "Capabilities refreshed"
-    finally:
-        mcp_service.reset()
-
-
-def test_mcp_service_filters_workflow_management_tools_for_non_assistant(
-    monkeypatch,
-    tmp_path,
-):
-    settings_file = tmp_path / "settings.json"
-    settings_file.write_text("{}", encoding="utf-8")
-    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
-    monkeypatch.setattr(settings_module, "_cached_settings", None)
-    monkeypatch.setattr(
-        "flowent.mcp_service.get_settings",
-        lambda: Settings(
-            mcp_servers=[
-                MCPServerConfig(
-                    name="flowent",
-                    transport="stdio",
-                )
-            ]
-        ),
-    )
-    mcp_service.reset()
-
-    try:
-        mcp_service._set_snapshot(
-            MCPDiscoverySnapshot(
-                server_name="flowent",
-                transport="stdio",
-                status="connected",
-                auth_status="unsupported",
-                tools=[
-                    MCPToolDescriptor(
-                        server_name="flowent",
-                        tool_name="list_workflows",
-                        fully_qualified_id="mcp__flowent__list_workflows",
-                    ),
-                    MCPToolDescriptor(
-                        server_name="flowent",
-                        tool_name="search_notes",
-                        fully_qualified_id="mcp__flowent__search_notes",
-                    ),
-                ],
-            )
-        )
-        worker = Agent(NodeConfig(node_type=NodeType.AGENT), uuid="worker")
-        assistant = Agent(NodeConfig(node_type=NodeType.ASSISTANT), uuid="assistant")
-
-        worker_tools = {
-            descriptor.fully_qualified_id
-            for descriptor in mcp_service.list_agent_dynamic_tools(worker)
-        }
-        assistant_tools = {
-            descriptor.fully_qualified_id
-            for descriptor in mcp_service.list_agent_dynamic_tools(assistant)
-        }
-
-        assert worker_tools == {"mcp__flowent__search_notes"}
-        assert assistant_tools == {
-            "mcp__flowent__list_workflows",
-            "mcp__flowent__search_notes",
-        }
-    finally:
-        mcp_service.reset()

package/backend/tests/unit/test_workspace_store.py

@@ -1,231 +0,0 @@
-import json
-import sqlite3
-
-from flowent.settings import Settings
-from flowent.state_db import open_state_db
-from flowent.workspace_store import workspace_store
-
-
-def test_workspace_store_normalizes_relative_write_dirs_on_load(
-    monkeypatch,
-    tmp_path,
-):
-    import flowent.settings as settings_module
-
-    settings_file = tmp_path / "settings.json"
-    workspace_file = tmp_path / "workspace.json"
-    working_dir = tmp_path / "workspace-root"
-    working_dir.mkdir()
-    workspace_file.write_text(
-        json.dumps(
-            {
-                "tabs": [],
-                "nodes": [
-                    {
-                        "id": "node-1",
-                        "config": {
-                            "node_type": "agent",
-                            "role_name": "Worker",
-                            "tab_id": "tab-1",
-                            "name": "Worker",
-                            "tools": ["read"],
-                            "write_dirs": ["./out"],
-                            "allow_network": False,
-                        },
-                        "state": "idle",
-                        "todos": [],
-                        "history": [],
-                    }
-                ],
-                "edges": [],
-                "blueprints": [],
-            }
-        ),
-        encoding="utf-8",
-    )
-
-    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
-    monkeypatch.setattr(
-        settings_module,
-        "get_settings",
-        lambda: Settings(working_dir=str(working_dir)),
-    )
-    workspace_store.reset_cache()
-
-    record = workspace_store.get_node_record("node-1")
-
-    assert record is not None
-    assert record.config.write_dirs == [str((working_dir / "out").resolve())]
-    connection = open_state_db(create=False)
-    assert connection is not None
-    try:
-        row = connection.execute(
-            "SELECT payload FROM nodes WHERE id = ?",
-            ("node-1",),
-        ).fetchone()
-    finally:
-        connection.close()
-    assert row is not None
-    persisted = json.loads(row["payload"])
-    assert persisted["config"]["write_dirs"] == [str((working_dir / "out").resolve())]
-    workspace_store.reset_cache()
-
-
-def test_workspace_store_prefers_legacy_workspace_data_when_state_db_is_still_empty(
-    monkeypatch,
-    tmp_path,
-):
-    import flowent.settings as settings_module
-
-    settings_file = tmp_path / "settings.json"
-    workspace_file = tmp_path / "workspace.json"
-    state_db_file = tmp_path / "state.sqlite"
-    settings_file.write_text("{}", encoding="utf-8")
-    workspace_file.write_text(
-        json.dumps(
-            {
-                "tabs": [],
-                "nodes": [
-                    {
-                        "id": "node-legacy",
-                        "config": {
-                            "node_type": "agent",
-                            "role_name": "Worker",
-                            "tab_id": "tab-1",
-                            "name": "Worker",
-                            "tools": ["read"],
-                            "write_dirs": [],
-                            "allow_network": False,
-                        },
-                        "state": "idle",
-                        "todos": [],
-                        "history": [],
-                    }
-                ],
-                "edges": [],
-                "blueprints": [],
-            }
-        ),
-        encoding="utf-8",
-    )
-    sqlite3.connect(state_db_file).close()
-
-    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
-    monkeypatch.setattr(settings_module, "_cached_settings", None)
-    monkeypatch.setattr(
-        settings_module,
-        "get_settings",
-        lambda: Settings(working_dir=str(tmp_path)),
-    )
-    workspace_store.reset_cache()
-
-    record = workspace_store.get_node_record("node-legacy")
-
-    assert record is not None
-    assert record.id == "node-legacy"
-    workspace_store.reset_cache()
-
-
-def test_workspace_store_does_not_overwrite_state_db_with_legacy_workspace_data(
-    monkeypatch,
-    tmp_path,
-):
-    import flowent.settings as settings_module
-
-    settings_file = tmp_path / "settings.json"
-    workspace_file = tmp_path / "workspace.json"
-    settings_file.write_text("{}", encoding="utf-8")
-    workspace_file.write_text(
-        json.dumps(
-            {
-                "tabs": [],
-                "nodes": [
-                    {
-                        "id": "node-legacy",
-                        "config": {
-                            "node_type": "agent",
-                            "role_name": "Worker",
-                            "tab_id": "tab-1",
-                            "name": "Legacy",
-                            "tools": ["read"],
-                            "write_dirs": [],
-                            "allow_network": False,
-                        },
-                        "state": "idle",
-                        "todos": [],
-                        "history": [],
-                    }
-                ],
-                "edges": [],
-                "blueprints": [],
-            }
-        ),
-        encoding="utf-8",
-    )
-
-    monkeypatch.setattr(settings_module, "_SETTINGS_FILE", settings_file)
-    monkeypatch.setattr(settings_module, "_cached_settings", None)
-    monkeypatch.setattr(
-        settings_module,
-        "get_settings",
-        lambda: Settings(working_dir=str(tmp_path)),
-    )
-    connection = open_state_db(create=True)
-    assert connection is not None
-    try:
-        with connection:
-            connection.execute(
-                """
-                INSERT INTO nodes (id, payload, tab_id, node_type, updated_at)
-                VALUES (?, ?, ?, ?, ?)
-                """,
-                (
-                    "node-sqlite",
-                    json.dumps(
-                        {
-                            "id": "node-sqlite",
-                            "config": {
-                                "node_type": "agent",
-                                "role_name": "Worker",
-                                "tab_id": "tab-1",
-                                "name": "SQLite",
-                                "tools": ["read"],
-                                "write_dirs": [],
-                                "allow_network": False,
-                            },
-                            "state": "idle",
-                            "todos": [],
-                            "history": [],
-                        }
-                    ),
-                    "tab-1",
-                    "agent",
-                    1.0,
-                ),
-            )
-    finally:
-        connection.close()
-
-    workspace_store.reset_cache()
-
-    sqlite_record = workspace_store.get_node_record("node-sqlite")
-    legacy_record = workspace_store.get_node_record("node-legacy")
-
-    assert sqlite_record is not None
-    assert legacy_record is None
-    connection = open_state_db(create=False)
-    assert connection is not None
-    try:
-        sqlite_row = connection.execute(
-            "SELECT id FROM nodes WHERE id = ?",
-            ("node-sqlite",),
-        ).fetchone()
-        legacy_row = connection.execute(
-            "SELECT id FROM nodes WHERE id = ?",
-            ("node-legacy",),
-        ).fetchone()
-    finally:
-        connection.close()
-    assert sqlite_row is not None
-    assert legacy_row is None
-    workspace_store.reset_cache()